text:
#include <aws/core/utils/Outcome.h>
#include <aws/core/auth/AWSAuthSigner.h>
#include <aws/core/client/CoreErrors.h>
#include <aws/core/client/RetryStrategy.h>
#include <aws/core/http/HttpClient.h>
#include <aws/core/http/HttpResponse.h>
#include <aws/core/http/HttpClientFactory.h>
#include <aws/core/auth/AWSCredentialsProviderChain.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
#include <aws/core/utils/threading/Executor.h>
#include <aws/core/utils/DNS.h>
#include <aws/core/utils/logging/LogMacros.h>
#include <aws/core/utils/logging/ErrorMacros.h>

#include <aws/connect-contact-lens/ConnectContactLensClient.h>
#include <aws/connect-contact-lens/ConnectContactLensErrorMarshaller.h>
#include <aws/connect-contact-lens/ConnectContactLensEndpointProvider.h>
#include <aws/connect-contact-lens/model/ListRealtimeContactAnalysisSegmentsRequest.h>

using namespace Aws;
using namespace Aws::Auth;
using namespace Aws::Client;
using namespace Aws::ConnectContactLens;
using namespace Aws::ConnectContactLens::Model;
using namespace Aws::Http;
using namespace Aws::Utils::Json;
using ResolveEndpointOutcome = Aws::Endpoint::ResolveEndpointOutcome;

const char* ConnectContactLensClient::SERVICE_NAME = "connect";
const char* ConnectContactLensClient::ALLOCATION_TAG = "ConnectContactLensClient";

ConnectContactLensClient::ConnectContactLensClient(const ConnectContactLens::ConnectContactLensClientConfiguration& clientConfiguration,
                                                   std::shared_ptr<ConnectContactLensEndpointProviderBase> endpointProvider) :
  BASECLASS(clientConfiguration,
            Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG,
                                             Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
                                             SERVICE_NAME,
                                             Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
            Aws::MakeShared<ConnectContactLensErrorMarshaller>(ALLOCATION_TAG)),
  m_clientConfiguration(clientConfiguration),
  m_executor(clientConfiguration.executor),
  m_endpointProvider(std::move(endpointProvider))
{
  init(m_clientConfiguration);
}

ConnectContactLensClient::ConnectContactLensClient(const AWSCredentials& credentials,
                                                   std::shared_ptr<ConnectContactLensEndpointProviderBase> endpointProvider,
                                                   const ConnectContactLens::ConnectContactLensClientConfiguration& clientConfiguration) :
  BASECLASS(clientConfiguration,
            Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG,
                                             Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
                                             SERVICE_NAME,
                                             Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
            Aws::MakeShared<ConnectContactLensErrorMarshaller>(ALLOCATION_TAG)),
    m_clientConfiguration(clientConfiguration),
    m_executor(clientConfiguration.executor),
    m_endpointProvider(std::move(endpointProvider))
{
  init(m_clientConfiguration);
}

ConnectContactLensClient::ConnectContactLensClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
                                                   std::shared_ptr<ConnectContactLensEndpointProviderBase> endpointProvider,
                                                   const ConnectContactLens::ConnectContactLensClientConfiguration& clientConfiguration) :
  BASECLASS(clientConfiguration,
            Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG,
                                             credentialsProvider,
                                             SERVICE_NAME,
                                             Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
            Aws::MakeShared<ConnectContactLensErrorMarshaller>(ALLOCATION_TAG)),
    m_clientConfiguration(clientConfiguration),
    m_executor(clientConfiguration.executor),
    m_endpointProvider(std::move(endpointProvider))
{
  init(m_clientConfiguration);
}

    /* Legacy constructors due deprecation */
  ConnectContactLensClient::ConnectContactLensClient(const Client::ClientConfiguration& clientConfiguration) :
  BASECLASS(clientConfiguration,
            Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG,
                                             Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
                                             SERVICE_NAME,
                                             Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
            Aws::MakeShared<ConnectContactLensErrorMarshaller>(ALLOCATION_TAG)),
  m_clientConfiguration(clientConfiguration),
  m_executor(clientConfiguration.executor),
  m_endpointProvider(Aws::MakeShared<ConnectContactLensEndpointProvider>(ALLOCATION_TAG))
{
  init(m_clientConfiguration);
}

ConnectContactLensClient::ConnectContactLensClient(const AWSCredentials& credentials,
                                                   const Client::ClientConfiguration& clientConfiguration) :
  BASECLASS(clientConfiguration,
            Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG,
                                             Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
                                             SERVICE_NAME,
                                             Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
            Aws::MakeShared<ConnectContactLensErrorMarshaller>(ALLOCATION_TAG)),
    m_clientConfiguration(clientConfiguration),
    m_executor(clientConfiguration.executor),
    m_endpointProvider(Aws::MakeShared<ConnectContactLensEndpointProvider>(ALLOCATION_TAG))
{
  init(m_clientConfiguration);
}

ConnectContactLensClient::ConnectContactLensClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
                                                   const Client::ClientConfiguration& clientConfiguration) :
  BASECLASS(clientConfiguration,
            Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG,
                                             credentialsProvider,
                                             SERVICE_NAME,
                                             Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
            Aws::MakeShared<ConnectContactLensErrorMarshaller>(ALLOCATION_TAG)),
    m_clientConfiguration(clientConfiguration),
    m_executor(clientConfiguration.executor),
    m_endpointProvider(Aws::MakeShared<ConnectContactLensEndpointProvider>(ALLOCATION_TAG))
{
  init(m_clientConfiguration);
}

    /* End of legacy constructors due deprecation */
ConnectContactLensClient::~ConnectContactLensClient()
{
}

std::shared_ptr<ConnectContactLensEndpointProviderBase>& ConnectContactLensClient::accessEndpointProvider()
{
  return m_endpointProvider;
}

void ConnectContactLensClient::init(const ConnectContactLens::ConnectContactLensClientConfiguration& config)
{
  AWSClient::SetServiceClientName("Connect Contact Lens");
  AWS_CHECK_PTR(SERVICE_NAME, m_endpointProvider);
  m_endpointProvider->InitBuiltInParameters(config);
}

void ConnectContactLensClient::OverrideEndpoint(const Aws::String& endpoint)
{
  AWS_CHECK_PTR(SERVICE_NAME, m_endpointProvider);
  m_endpointProvider->OverrideEndpoint(endpoint);
}

ListRealtimeContactAnalysisSegmentsOutcome ConnectContactLensClient::ListRealtimeContactAnalysisSegments(const ListRealtimeContactAnalysisSegmentsRequest& request) const
{
  AWS_OPERATION_CHECK_PTR(m_endpointProvider, ListRealtimeContactAnalysisSegments, CoreErrors, CoreErrors::ENDPOINT_RESOLUTION_FAILURE);
  ResolveEndpointOutcome endpointResolutionOutcome = m_endpointProvider->ResolveEndpoint(request.GetEndpointContextParams());
  AWS_OPERATION_CHECK_SUCCESS(endpointResolutionOutcome, ListRealtimeContactAnalysisSegments, CoreErrors, CoreErrors::ENDPOINT_RESOLUTION_FAILURE, endpointResolutionOutcome.GetError().GetMessage());
  endpointResolutionOutcome.GetResult().AddPathSegments("/realtime-contact-analysis/analysis-segments");
  return ListRealtimeContactAnalysisSegmentsOutcome(MakeRequest(request, endpointResolutionOutcome.GetResult(), Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
}

ListRealtimeContactAnalysisSegmentsOutcomeCallable ConnectContactLensClient::ListRealtimeContactAnalysisSegmentsCallable(const ListRealtimeContactAnalysisSegmentsRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< ListRealtimeContactAnalysisSegmentsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRealtimeContactAnalysisSegments(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConnectContactLensClient::ListRealtimeContactAnalysisSegmentsAsync(const ListRealtimeContactAnalysisSegmentsRequest& request, const ListRealtimeContactAnalysisSegmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context]()
    {
      handler(this, request, ListRealtimeContactAnalysisSegments(request), context);
    } );
}


text:
@interface UIApplication(IDNExt)

+ (id<UIApplicationDelegate>)appDelegate;

@end

redpajama_set_name: RedPajamaGithub


text:
from PIL import Image, ImageDraw, ImageFont, ImageFilter
from tools import colorer, stringer
import types, os

# 打开
def open_image(image_path=None):
    if image_path is None or len(image_path) == 0:
        return None

    im = Image.open(image_path)
    return im

# 显示
def show_image(image_path=None):
    im = open_image(image_path)
    im.show()

# 保存
def save(image=None, to_path=None):
    if image is None or to_path is None or len(to_path) == 0:
        return

    f, e = os.path.splitext(to_path)
    if e is None or len(e) == 0:
        image.save(to_path, "JPEG")
    else:
        image.save(to_path)

# 大小
def image_size(image=None):
    ret_size = (0, 0)

    if image is None:
        return ret_size

    return image.size

# 拷贝
def image_copy(image=None):
    if image is None:
        return None

    return image.copy()

# 裁剪
def image_crop(image=None, box=None):
    if image is None or box is None:
        return None

    return image.crop(box)

# 压缩
def get_thumb(image=None, ratio=0.6):
    if ratio > 1:
        return image
    if ratio <= 0 or image is None:
        return None

    w, h = image.size()

    return image.thumbnail((w * ratio, h * ratio))

# # 合并
# def paste(image=None, sub_image=None, origin=(0, 0)):
#     if image is None or sub_image is None:
#         return None
#
#     im = image
#     if type(image) is types.StringType:
#         im = Image.open(image)
#         if im is None:
#             return None
#
#     sub_im = sub_image
#     if type(sub_image) is types.StringType:
#         sub_im = Image.open(sub_image)
#         if sub_im is None:
#             return None
#
#     im_size = im.size
#     sub_size = sub_im.size
#     # 如果sub_image在image范围内,不需要创建新的图片
#     if origin[0] >= 0 and origin[1] >= 0:
#         right = origin[0] + sub_size[0]
#         bottom = origin[1] + sub_size[1]
#         if right <= im.size[0] and bottom <= im_size[1]:
#             return im.paste(sub_im, (origin(0), origin(1), right, bottom))
#
#     right = im_size(0)
#     if im_size(0) < sub_size(0):
#         width = sub_size(0)
#     height = im_size(1)
#     if im_size(1) < sub_size(1):
#         height = sub_size(1)
#
#
#     image = Image.new('RGB', (width, height), (255, 255, 255))
#
#
#     return im.paste(sub_im, box)

# 添加文字
def draw_text(image=None, text=None, origin=(0, 0), font=None, fill='red'):
    if image is None or text is None or len(text) == 0:
        return None

    context = ImageDraw.Draw(image)
    context.text(origin, text, font=font, fill=fill)
    return image

# 旋转
def image_rotate(image=None, rotate=0):

    if image is None:
        return None

    if rotate == 0:
        return image

    return image.rotate(rotate)

# 转换色彩模式, mode: 'P'虚化,'L'或者'1'黑白,'LA'怀旧
def image_convert(image=None, mode='P'):
    if image is None:
        return None

    return image.convert(mode)

# 生成验证码图片:数字和字母
def verification_code(num=4, width=240, height=60, font_size=30):
    image = Image.new('RGB', (width, height), (255, 255, 255))
    font = ImageFont.truetype('Arial.ttf', font_size)
    draw = ImageDraw.Draw(image)

    # 背景填充
    for x in range(width):
        for y in range(height):
            draw.point((x, y), colorer.randRGB(min=64))

    # 文字
    tw = width / num
    margin = (tw - font_size) / 2
    ty = (height - font_size) / 2
    tx = margin
    str = ""
    for t in range(num):
        char = stringer.rand_char()
        draw.text((tx, ty), char, font=font, fill=colorer.randRGB(0, 100))
        tx = tx + tw
        str = str + char

    # 模糊效果
    image = image.filter(ImageFilter.BLUR)

    return image, str

# 生成中文验证码

# 重置图片大小
def reset_image_size(image=None, max_width=None, max_height=None):
    if image is None or max_width is None or max_height is None:
        return

    if image.size[0] <= max_width and image.size[1] <= max_height:
        return

    rotate = image.size[0] / image.size[1]
    if rotate > 1:
        new_width = max_width
        new_height = max_width / rotate
    else:
        new_height = max_height
        new_width = max_height * rotate

    new_image = image.resize((int(new_width), int(new_height)), Image.BILINEAR)
    return new_image


text:
You need to obtain your API key here: http://www.hvv.de/fahrplaene/fahrplanauskunft/datenschnittstelle/

# Install

1. Clone repository into `../modules/` inside your MagicMirror folder.
2. Run `npm install` inside `../modules/MMM-HH-LocalTransport/` folder
3. Run `node findStation.js apiKey apiUser stationName` to find out your Station ID.
4. Add the module to the MagicMirror config
```
		{
	        module: 'MMM-HH-LocalTransport',
	        position: 'bottom_right',
	        header: 'Connections',
	        config: {
	            id: '', // Trainstation ID
	            apiKey: '', // Add your apiKey
	            apiUser: '', // Add your apiUser
		    customAPI: false, // or true
		    customUrl: 'http://api/v1/getSignature',
		    customAPIToken: 'token123',
		    updateInterval: 60000,
		    maximumEntries: '10' // Max departures displayed
	        }
    	},
```
# Screenshot
![screenshot](https://cloud.githubusercontent.com/assets/6489464/16900320/11ec448a-4c22-11e6-8754-181862a52540.png)

# Further information
For all config options check [here](https://github.com/georg90/MMM-HH-LocalTransport/blob/master/MMM-HH-LocalTransport.js#L15-L31).


text:
require 'mocha/parameter_matchers'
require 'mocha/mockery'
require 'mocha/sequence'

module Mocha

  # Methods added to +Test::Unit::TestCase+ or equivalent.
  module API

    include ParameterMatchers

    # Builds a new mock object
    #
    # @param [String] name identifies mock object in error messages.
    # @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
    # @yield optional block to be evaluated against the mock object instance, giving an alternative way to setup expectations.
    # @return [Mock] a new mock object
    #
    # @overload def mock(name, &block)
    # @overload def mock(expected_methods_vs_return_values = {}, &block)
    # @overload def mock(name, expected_methods_vs_return_values = {}, &block)
    #
    # @example Using expected_methods_vs_return_values Hash to setup expectations.
    #   def test_motor_starts_and_stops
    #     motor = mock('motor', :start => true, :stop => true)
    #     assert motor.start
    #     assert motor.stop
    #     # an error will be raised unless both Motor#start and Motor#stop have been called
    #   end
    # @example Using the optional block to setup expectations & stubbed methods.
    #   def test_motor_starts_and_stops
    #     motor = mock('motor') do
    #       expects(:start).with(100.rpm).returns(true)
    #       stubs(:stop).returns(true)
    #     end
    #     assert motor.start(100.rpm)
    #     assert motor.stop
    #     # an error will only be raised if Motor#start(100.rpm) has not been called
    #   end
    def mock(*arguments, &block)
      name = arguments.shift if arguments.first.is_a?(String)
      expectations = arguments.shift || {}
      mock = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
      mock.expects(expectations)
      mock
    end

    # Builds a new mock object
    #
    # @param [String] name identifies mock object in error messages.
    # @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
    # @yield optional block to be evaluated against the mock object instance, giving an alternative way to setup stubbed methods.
    # @return [Mock] a new mock object
    #
    # @overload def stub(name, &block)
    # @overload def stub(stubbed_methods_vs_return_values = {}, &block)
    # @overload def stub(name, stubbed_methods_vs_return_values = {}, &block)
    #
    # @example Using stubbed_methods_vs_return_values Hash to setup stubbed methods.
    #   def test_motor_starts_and_stops
    #     motor = mock('motor', :start => true, :stop => true)
    #     assert motor.start
    #     assert motor.stop
    #     # an error will not be raised even if either Motor#start or Motor#stop has not been called
    #   end
    #
    # @example Using the optional block to setup expectations & stubbed methods.
    #   def test_motor_starts_and_stops
    #     motor = mock('motor') do
    #       expects(:start).with(100.rpm).returns(true)
    #       stubs(:stop).returns(true)
    #     end
    #     assert motor.start(100.rpm)
    #     assert motor.stop
    #     # an error will only be raised if Motor#start(100.rpm) has not been called
    #   end
    def stub(*arguments, &block)
      name = arguments.shift if arguments.first.is_a?(String)
      expectations = arguments.shift || {}
      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
      stub.stubs(expectations)
      stub
    end

    # Builds a mock object that accepts calls to any method. By default it will return +nil+ for any method call.
    #
    # @param [String] name identifies mock object in error messages.
    # @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
    # @yield optional block to be evaluated against the mock object instance, giving an alternative way to setup stubbed methods.
    # @return [Mock] a new mock object
    #
    # @overload def stub_everything(name, &block)
    # @overload def stub_everything(stubbed_methods_vs_return_values = {}, &block)
    # @overload def stub_everything(name, stubbed_methods_vs_return_values = {}, &block)
    #
    # @example Ignore invocations of irrelevant methods.
    #   def test_motor_stops
    #     motor = stub_everything('motor', :stop => true)
    #     assert_nil motor.irrelevant_method_1 # => no error raised
    #     assert_nil motor.irrelevant_method_2 # => no error raised
    #     assert motor.stop
    #   end
    def stub_everything(*arguments, &block)
      name = arguments.shift if arguments.first.is_a?(String)
      expectations = arguments.shift || {}
      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
      stub.stub_everything
      stub.stubs(expectations)
      stub
    end

    # Builds a new sequence which can be used to constrain the order in which expectations can occur.
    #
    # Specify that an expected invocation must occur within a named {Sequence} by using {Expectation#in_sequence}.
    #
    # @return [Sequence] a new sequence
    #
    # @see Expectation#in_sequence
    #
    # @example Ensure methods on egg are invoked in correct order.
    #   breakfast = sequence('breakfast')
    #
    #   egg = mock('egg') do
    #     expects(:crack).in_sequence(breakfast)
    #     expects(:fry).in_sequence(breakfast)
    #     expects(:eat).in_sequence(breakfast)
    #   end
    def sequence(name)
      Sequence.new(name)
    end

    # Builds a new state machine which can be used to constrain the order in which expectations can occur.
    #
    # Specify the initial state of the state machine by using {StateMachine#starts_as}.
    #
    # Specify that an expected invocation should change the state of the state machine by using {Expectation#then}.
    #
    # Specify that an expected invocation should be constrained to occur within a particular +state+ by using {Expectation#when}.
    #
    # A test can contain multiple state machines.
    #
    # @return [StateMachine] a new state machine
    #
    # @see Expectation#then
    # @see Expectation#when
    # @see StateMachine
    # @example Constrain expected invocations to occur in particular states.
    #   power = states('power').starts_as('off')
    #
    #   radio = mock('radio') do
    #     expects(:switch_on).then(power.is('on'))
    #     expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
    #     expects(:adjust_volume).with(+5).when(power.is('on'))
    #     expects(:select_channel).with('BBC World Service').when(power.is('on'))
    #     expects(:adjust_volume).with(-5).when(power.is('on'))
    #     expects(:switch_off).then(power.is('off'))
    #   end
    def states(name)
      Mockery.instance.new_state_machine(name)
    end

    # @private
    def mocha_setup
    end

    # @private
    def mocha_verify(assertion_counter = nil)
      Mockery.instance.verify(assertion_counter)
    end

    # @private
    def mocha_teardown
      Mockery.instance.teardown
      Mockery.reset_instance
    end

  end

end


text:
<?php namespace Ixudra\Portfolio\Http\Requests\Projects;

use Ixudra\Core\Http\Requests\BaseRequest;
use Ixudra\Portfolio\Interfaces\Services\Validation\ProjectValidationHelperInterface;

use App;

class UpdateProjectFormRequest extends BaseRequest {

    public function authorize()
    {
        return true;
    }

    public function rules()
    {
        return App::make( ProjectValidationHelperInterface::class )
            ->getFormValidationRules( 'update' );
    }

    public function getInput($includeFiles = false)
    {
        $input = parent::getInput( $includeFiles );

        $input[ 'hidden' ] = $this->convertToTruthyValue( $input, 'hidden' );

        return $input;
    }

}


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">Climate</string>
    <string name="working">"Working…"</string>
</resources>


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

<META http-equiv="Content-Type" content="text/html; charset=utf-8">
<TITLE>
java.awt (Java Platform SE 6)
</TITLE>

<META NAME="date" CONTENT="2007-03-19">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../stylesheet.css" TITLE="Style">

java.awt

接口

ActiveEvent

Adjustable

Composite

CompositeContext

ItemSelectable

KeyEventDispatcher

KeyEventPostProcessor

LayoutManager

LayoutManager2

MenuContainer

Paint

PaintContext

PrintGraphics

Shape

Stroke

Transparency

类

AlphaComposite

AWTEvent

AWTEventMulticaster

AWTKeyStroke

AWTPermission

BasicStroke

BorderLayout

BufferCapabilities

BufferCapabilities.FlipContents

Button

Canvas

CardLayout

Checkbox

CheckboxGroup

CheckboxMenuItem

Choice

Color

Component

ComponentOrientation

Container

ContainerOrderFocusTraversalPolicy

Cursor

DefaultFocusTraversalPolicy

DefaultKeyboardFocusManager

Desktop

Dialog

Dimension

DisplayMode

Event

EventQueue

FileDialog

FlowLayout

FocusTraversalPolicy

Font

FontMetrics

Frame

GradientPaint

Graphics

Graphics2D

GraphicsConfigTemplate

GraphicsConfiguration

GraphicsDevice

GraphicsEnvironment

GridBagConstraints

GridBagLayout

GridBagLayoutInfo

GridLayout

Image

ImageCapabilities

Insets

JobAttributes

JobAttributes.DefaultSelectionType

JobAttributes.DestinationType

JobAttributes.DialogType

JobAttributes.MultipleDocumentHandlingType

JobAttributes.SidesType

KeyboardFocusManager

Label

LinearGradientPaint

List

MediaTracker

Menu

MenuBar

MenuComponent

MenuItem

MenuShortcut

MouseInfo

MultipleGradientPaint

PageAttributes

PageAttributes.ColorType

PageAttributes.MediaType

PageAttributes.OrientationRequestedType

PageAttributes.OriginType

PageAttributes.PrintQualityType

Panel

Point

PointerInfo

Polygon

PopupMenu

PrintJob

RadialGradientPaint

Rectangle

RenderingHints

RenderingHints.Key

Robot

Scrollbar

ScrollPane

ScrollPaneAdjustable

SplashScreen

SystemColor

SystemTray

TextArea

TextComponent

TextField

TexturePaint

Toolkit

TrayIcon

Window

枚举

Component.BaselineResizeBehavior

Desktop.Action

Dialog.ModalExclusionType

Dialog.ModalityType

MultipleGradientPaint.ColorSpaceType

MultipleGradientPaint.CycleMethod

TrayIcon.MessageType

异常

AWTException

FontFormatException

HeadlessException

IllegalComponentStateException

错误

AWTError


text:
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Score.cs" company="yoshikazu yananose">
//   (c) 2016 machi no omochaya-san.
// </copyright>
//
//   The score.
//
// --------------------------------------------------------------------------------------------------------------------
namespace Omochaya.Common
{
    using System;

    /// The score.
    public class Score
    {
        /// The now.
        private int now = 0;

        /// The pass line.
        private float passLine = 0f;

        /// The time.
        private int time = 0;

        /// The is pass.
        public bool IsPass { get; private set; }

        /// The constructor.
        public Score(float passLine, int time)
        {
            this.now = 0;
            this.passLine = passLine;
            this.time = Math.Max(1, time);
            this.IsPass = false;
        }

        /// The update.
        public bool Update(float diff, float diffCand)
        {
            var ret = false;
            if (diff < this.passLine)
            {
                this.now++;
            }
            else if (diffCand < this.passLine)
            {
                this.now--;
            }

            if (this.now < 0)
            {
                this.now = this.time;
                this.IsPass = false;
                ret = true;
            }
            else
            {
                this.now = Math.Min(this.now, this.time * 3);
                if (this.time * 2 < this.now)
                {
                    this.IsPass = true;
                }
            }

            return ret;
        }
    }
}


text:
var CFYO = {};

$(function(){
	jQuery.CFYO.mainNav();
	jQuery.CFYO.TurnItOn("#navigation");
	jQuery.CFYO.GrowPageLine();
	jQuery.CFYO.searchBox();
});

	jQuery.CFYO = {

		Compactor : function(list,trigger,target,topOffset){
			$(list).find(trigger).addClass(" link").hover(function(){
				$(this).addClass(" linkOver");
			},function(){
				$(this).removeClass("linkOver");
			}).click(function(){
				$(list).find(target+":visible").not(this).slideUp("def");
				$(list).find(trigger).not(this).removeClass("linkOn");
				$(this).addClass(" linkOn").next(target+":hidden").slideDown("def");
			});
		},

		mainNav : function(){
			$('.level_1').find('li').hover(function(){
				$(this).children('ul.level_2').css({display:'block'});
			},function(){
				$(this).children('ul.level_2').css({display:'none'});
			});
			$('.level_2').find('li').hover(function(){
				$(this).children('ul.level_3').css({display:'block'});
			},function(){
				$(this).children('ul.level_3').css({display:'none'});
			});
			$('.level_1').find('a').each(function(){
				if($(this).attr('href').split('/')[3]=='#'){
					$(this).css('cursor','CFYO').click(function(){
						return false;
					});
				}
			});
		},

		TurnItOn : function(nav){
			$(nav).find("a").each(function(){
				if(location.href.indexOf(this.href)!=-1){
					$(this).addClass(" on").parent().parent("ul").parent("li").find("a:first").addClass(" on");
				}});
		},

		GrowPageLine : function()
		{
		var PLH = $('#primaryContent').height();
		$('.page_line').height(PLH+'px');
		},

		searchBox : function()
		{
			$('#searchbox').find('form').submit(function()
			{
			var searchField = $('.searchbox').find('.field').val();
			if(searchField.length <= 3)
				{
				$('.searchbox').append('
You must enter a string longer than 3 characters!
');
				$('.min_char').delay('5000').fadeOut('slow');
				return false;
				}
			})
		}
	}


text:
using System;
using System.Reflection;
using System.Threading.Tasks;

namespace RemoteExecutorConsoleApp
{
    /// <summary>
    /// Provides an entry point in a new process that will load a specified method and invoke it.
    /// </summary>
    internal static class Program
    {
        static int Main(string[] args)
        {
            // The program expects to be passed the target assembly name to load, the type
            // from that assembly to find, and the method from that assembly to invoke.
            // Any additional arguments are passed as strings to the method.
            if (args.Length < 3)
            {
                Console.Error.WriteLine("Usage: {0} assemblyName typeName methodName", typeof(Program).GetTypeInfo().Assembly.GetName().Name);
                return -1;
            }
            string assemblyName = args[0];
            string typeName = args[1];
            string methodName = args[2];
            string[] additionalArgs = args.Length > 3 ?
                args.Subarray(3, args.Length - 3) :
                Array.Empty<string>();

            // Load the specified assembly, type, and method, then invoke the method.
            // The program's exit code is the return value of the invoked method.
            Assembly a = null;
            Type t = null;
            MethodInfo mi = null;
            object instance = null;
            try
            {
                a = Assembly.Load(new AssemblyName(assemblyName));
                t = a.GetType(typeName);
                mi = t.GetTypeInfo().GetDeclaredMethod(methodName);
                if (!mi.IsStatic)
                {
                    instance = Activator.CreateInstance(t);
                }
                object result = mi.Invoke(instance, additionalArgs);
                return result is Task<int> ?
                    ((Task<int>)result).GetAwaiter().GetResult() :
                    (int)result;
            }
            catch (Exception exc)
            {
                Console.Error.WriteLine("Exception from RemoteExecutorConsoleApp({0}):", string.Join(", ", args));
                Console.Error.WriteLine("Assembly: {0}", a);
                Console.Error.WriteLine("Type: {0}", t);
                Console.Error.WriteLine("Method: {0}", mi);
                Console.Error.WriteLine("Exception: {0}", exc);
                throw exc;
            }
            finally
            {
                IDisposable d = instance as IDisposable;
                if (d != null)
                {
                    d.Dispose();
                }
            }
        }

        private static MethodInfo GetMethod(this Type type, string methodName)
        {
            Type t = type;
            while (t != null)
            {
                TypeInfo ti = t.GetTypeInfo();
                MethodInfo mi = ti.GetDeclaredMethod(methodName);
                if (mi != null)
                {
                    return mi;
                }
                t = ti.BaseType;
            }
            return null;
        }

        private static T[] Subarray<T>(this T[] arr, int offset, int count)
        {
            var newArr = new T[count];
            Array.Copy(arr, offset, newArr, 0, count);
            return newArr;
        }
    }
}


text:
'use strict';

/**
* Retrieve resources from a GitHub API endpoint.
*
* @module @stdlib/_tools/github/get
*
* @example
* var get = require( '@stdlib/_tools/github/get' );
*
* get( onResponse );
*
* function onResponse( error, data, info ) {
*     // Check for rate limit info...
*     if ( info ) {
*         console.error( 'Limit: %d', info.limit );
*         console.error( 'Remaining: %d', info.remaining );
*         console.error( 'Reset: %s', (new Date( info.reset*1000 )).toISOString() );
*     }
*     if ( error ) {
*         if ( error instanceof Error ) {
*             throw error;
*         }
*         console.error( error.message );
*     } else {
*         console.log( JSON.stringify( data ) );
*     }
* }
*
* @example
* var factory = require( '@stdlib/_tools/github/get' ).factory;
*
* function onResponse( error, data, info ) {
*     // Check for rate limit info...
*     if ( info ) {
*         console.error( 'Limit: %d', info.limit );
*         console.error( 'Remaining: %d', info.remaining );
*         console.error( 'Reset: %s', (new Date( info.reset*1000 )).toISOString() );
*     }
*     if ( error ) {
*         if ( error instanceof Error ) {
*             throw error;
*         }
*         console.error( error.message );
*     } else {
*         console.log( JSON.stringify( data ) );
*     }
* }
*
* var options = {
*     'pathname': '/user/repos',
*     'page': 1,
*     'per_page': 100
* };
*
* var getRepos = factory( options, onReponse );
*
* // Make repeated requests:
* getRepos();
* getRepos();
*/

// MODULES //

var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
var main = require( './main.js' );
var factory = require( './factory.js' );

// MAIN //

setReadOnly( main, 'factory', factory );

// EXPORTS //

module.exports = main;


text:
@interface GlosarioDatos : NSObject{
NSMutableArray*arregloGlosarioDatos;
}

-(void)datosGlosario;
-(NSMutableArray*)getArregloGlosarioDatos;

@end


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
null

#### Original name
Gossypianthus tenuiflorus Hook.

### Remarks
null


text:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.0" language="it_IT">
<context>
    <name>design/standard/content/datatype</name>
    <message>
        <source>Current image</source>
        <translation>Immagine attuale</translation>
    </message>
    <message>
        <source>Preview</source>
        <translation>Anteprima</translation>
    </message>
    <message>
        <source>Filename</source>
        <translation>Nome file</translation>
    </message>
    <message>
        <source>MIME type</source>
        <translation>MIME type</translation>
    </message>
    <message>
        <source>Size</source>
        <translation>Dimensione</translation>
    </message>
    <message>
        <source>There is no image file.</source>
        <translation>Non vi è alcun file immagine.</translation>
    </message>
    <message>
        <source>Remove image</source>
        <translation>Elimina immagine</translation>
    </message>
    <message>
        <source>New image file for upload</source>
        <translation>Nuovo file immagine da caricare</translation>
    </message>
    <message>
        <source>Alternative image text</source>
        <translation>Testo alternativo immagine</translation>
    </message>
</context>
<context>
    <name>design/standard/ezie</name>
    <message>
        <source>Edit</source>
        <translation>Modifica</translation>
    </message>
    <message>
        <source>eZ Image Editor</source>
        <translation>eZ Image Editor</translation>
    </message>
    <message>
        <source>Save and Close</source>
        <translation>Salva e Chiudi</translation>
    </message>
    <message>
        <source>Save &amp; Close</source>
        <translation>Salva &amp; Chiudi</translation>
    </message>
    <message>
        <source>Close without saving</source>
        <translation>Chiudi senza salvare</translation>
    </message>
    <message>
        <source>Quit</source>
        <translation>Abbandona</translation>
    </message>
    <message>
        <source>Thumbnail</source>
        <translation>Miniatura</translation>
    </message>
    <message>
        <source>Rotation</source>
        <translation>Rotazione</translation>
    </message>
    <message>
        <source>Ok</source>
        <translation>Ok</translation>
    </message>
    <message>
        <source>Select</source>
        <translation>Seleziona</translation>
    </message>
    <message>
        <source>Dimensions</source>
        <translation>Dimensioni</translation>
    </message>
    <message>
        <source>Keep ratio</source>
        <translation>Mantieni proporzioni</translation>
    </message>
    <message>
        <source>Free</source>
        <translation>Libero</translation>
    </message>
    <message>
        <source>Crop</source>
        <translation>Taglia</translation>
    </message>
    <message>
        <source>Zoom</source>
        <translation>Ingrandisci</translation>
    </message>
    <message>
        <source>Actual pixels</source>
        <translation>Pixels attuali</translation>
    </message>
    <message>
        <source>Fit on screen</source>
        <translation>Allarga allo schermo</translation>
    </message>
    <message>
        <source>Watermarks</source>
        <translation>Watermarks</translation>
    </message>
    <message>
        <source>Apply</source>
        <translation>Applica</translation>
    </message>
    <message>
        <source>Contrast</source>
        <translation>Contrasto</translation>
    </message>
    <message>
        <source>Brightness</source>
        <translation>Luminosità</translation>
    </message>
    <message>
        <source>Actions</source>
        <translation>Azioni</translation>
    </message>
    <message>
        <source>Tools</source>
        <translation>Strumenti</translation>
    </message>
    <message>
        <source>Undo</source>
        <translation>Annulla</translation>
    </message>
    <message>
        <source>Redo</source>
        <translation>Ripeti</translation>
    </message>
    <message>
        <source>Image</source>
        <translation>Immagine</translation>
    </message>
    <message>
        <source>Horizontal Flip</source>
        <translation>Inverti in orizzontale</translation>
    </message>
    <message>
        <source>Vertical Flip</source>
        <translation>Inverti in verticale</translation>
    </message>
    <message>
        <source>Perform Crop</source>
        <translation>Esegui taglio</translation>
    </message>
    <message>
        <source>Watermark</source>
        <translation>Watermark</translation>
    </message>
    <message>
        <source>Effects</source>
        <translation>Effetti</translation>
    </message>
    <message>
        <source>Pixelate</source>
        <translation>Effetto pixel</translation>
    </message>
    <message>
        <source>Black and White</source>
        <translation>Bianco e Nero</translation>
    </message>
    <message>
        <source>Sepia</source>
        <translation>Seppia</translation>
    </message>
    <message>
        <source>Options</source>
        <translation>Opzioni</translation>
    </message>
    <message>
        <source>The image is not loaded because of a server error.</source>
        <translation>L'immagine non è stata caricata a causa di un errore del server.</translation>
    </message>
    <message>
        <source>Close</source>
        <translation>Chiudi</translation>
    </message>
</context>
</TS>


text:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!--

  Demonstrates the use of property-ref to map legacy data where
  foreign keys reference something other than the primary key of
  the associated entity. Here we show:

  (1) A one-to-one foreign key association (prefer primary key
      associations)

  (2) A bidirectional one-to-many association on a key that is
      comprised of several properties of the associated entity

-->

<hibernate-mapping package="org.hibernate.test.cuk">

	<class name="Person">

		<id name="id">
			<generator class="hilo"/>
		</id>

		<property name="name" length="100"/>

		<one-to-one name="address"
			property-ref="person"
			cascade="all"
			fetch="join"/>

		<set name="accounts"
			inverse="true">
			<key property-ref="userIdAndDeleted">
				<column name="userId"/>
				<column name="userDeleted"/>
			</key>
			<one-to-many class="Account"/>
		</set>

		<properties name="userIdAndDeleted"
			update="false">
			<property name="userId" length="8"/>
			<property name="deleted"/>
		</properties>

	</class>

	<class name="Address">

		<id name="id">
			<generator class="hilo"/>
		</id>

		<property name="address" length="300"/>
		<property name="zip" length="5"/>
		<property name="country" length="25"/>
		<many-to-one name="person" unique="true" not-null="true"/>

	</class>

	<class name="Account">

		<id name="accountId" length="32">
			<generator class="uuid.hex"/>
		</id>

		<many-to-one name="user"
			property-ref="userIdAndDeleted">
			<column name="userId"/>
			<column name="userDeleted"/>
		</many-to-one>

		<property name="type" not-null="true"/>

	</class>

</hibernate-mapping>


text:
#include "Modules/Editor/UI/Editor_Interface.h"
#include "Modules/Editor/UI/Hotkeys.h"
#include "Modules/Editor/UI/CameraController.h"
#include "Modules/Editor/UI/RotationIndicator.h"
#include "Modules/Editor/UI/TitleBar.h"
#include "Modules/Editor/UI/Prefabs.h"
#include "Modules/Editor/UI/SceneInspector.h"
#include "Modules/Editor/UI/EntityInspector.h"
#include "Modules/Editor/UI/RecoverDialogue.h"
#include "Modules/Editor/UI/OpenDialogue.h"
#include "Modules/Editor/UI/SaveDialogue.h"
#include "Modules/Editor/UI/UnsavedChangesDialogue.h"
#include "Modules/Editor/UI/MissingFileDialogue.h"
#include "Modules/Editor/UI/Settings.h"
#include "imgui.h"
#include "imgui_internal.h"
#include "examples/imgui_impl_glfw.h"
#include "examples/imgui_impl_opengl3.h"
#include "Engine.h"
#include "GLFW/glfw3.h"

Editor_Interface::~Editor_Interface()
{
	// Cleanup
	ImGui_ImplOpenGL3_Shutdown();
	ImGui_ImplGlfw_Shutdown();
	ImGui::DestroyContext();
}

Editor_Interface::Editor_Interface(Engine& engine, LevelEditor_Module& editor) :
	m_uiHotkeys(std::make_shared<Hotkeys>(engine, editor)),
	m_uiCamController(std::make_shared<CameraController>(engine)),
	m_uiRotIndicator(std::make_shared<RotationIndicator>(engine)),
	m_uiTitlebar(std::make_shared<TitleBar>(engine, editor)),
	m_uiPrefabs(std::make_shared<Prefabs>(engine, editor)),
	m_uiSceneInspector(std::make_shared<SceneInspector>(engine, editor)),
	m_uiEntityInspector(std::make_shared<EntityInspector>(engine, editor)),
	m_uiSettings(std::make_shared<Settings>(engine, editor)),
	m_uiRecoverDialogue(std::make_shared<RecoverDialogue>(engine, editor)),
	m_uiOpenDialogue(std::make_shared<OpenDialogue>(engine, editor)),
	m_uiSaveDialogue(std::make_shared<SaveDialogue>(engine, editor)),
	m_uiUnsavedDialogue(std::make_shared<UnsavedChangesDialogue>(engine, editor)),
	m_uiMissingDialogue(std::make_shared<MissingFileDialogue>(engine, editor)),
	m_engine(engine),
	m_editor(editor)
{
	// Preferences
	auto& preferences = engine.getPreferenceState();
	preferences.getOrSetValue(PreferenceState::Preference::C_WINDOW_WIDTH, m_renderSize.x);
	preferences.getOrSetValue(PreferenceState::Preference::C_WINDOW_HEIGHT, m_renderSize.y);
	preferences.addCallback(PreferenceState::Preference::C_WINDOW_WIDTH, m_aliveIndicator, [&](const float& f) noexcept {
		m_renderSize.x = static_cast<int>(f);
		});
	preferences.addCallback(PreferenceState::Preference::C_WINDOW_HEIGHT, m_aliveIndicator, [&](const float& f) noexcept {
		m_renderSize.y = static_cast<int>(f);
		});

	// Initialize ImGUI
	IMGUI_CHECKVERSION();
	ImGui::CreateContext();
	ImGuiIO& io = ImGui::GetIO(); (void)io;
	io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;	// Enable Keyboard Controls
	io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;	// Enable Game-pad Controls
	io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;		// Enable Game-pad Controls
	io.ConfigWindowsMoveFromTitleBarOnly = true;
	io.ConfigDockingWithShift = true;
	ImGuiStyle& style = ImGui::GetStyle();
	style.FrameRounding = 6.0F;

	// Setup Dear ImGui style
	ImGui::StyleColorsDark();

	// Setup Platform/Renderer bindings
	ImGui_ImplGlfw_InitForOpenGL(engine.getWindow().getContext(), true);
	ImGui_ImplOpenGL3_Init("#version 150");
}

void Editor_Interface::tick(const float& deltaTime)
{
	// Start the Dear ImGui frame
	ImGui_ImplOpenGL3_NewFrame();
	ImGui_ImplGlfw_NewFrame();
	ImGui::NewFrame();

	bool show_demo_window = true;
	ImGui::ShowDemoWindow(&show_demo_window);

	// Prepare the docking regions
	const auto dockspace_size = ImVec2(static_cast<float>(m_renderSize.x) / 5.0F, static_cast<float>(m_renderSize.y));
	constexpr auto window_flags = ImGuiWindowFlags_NoTitleBar |
		ImGuiWindowFlags_MenuBar |
		ImGuiWindowFlags_NoMove |
		ImGuiWindowFlags_NoBringToFrontOnFocus |
		ImGuiWindowFlags_NoNavFocus |
		ImGuiWindowFlags_NoDocking |
		ImGuiWindowFlags_NoBackground;

	ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0F);
	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0F, 0.0F));
	ImGui::SetNextWindowBgAlpha(0.0F);
	ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Appearing);
	ImGui::SetNextWindowSize(dockspace_size, ImGuiCond_Appearing);
	ImGui::Begin("Docking Area A", nullptr, window_flags);
	const auto dockspace_id_a = ImGui::GetID("Docking Space A");
	if (ImGui::DockBuilderGetNode(dockspace_id_a) == nullptr) {
		ImGui::DockBuilderRemoveNode(dockspace_id_a); // Clear out existing layout
		ImGui::DockBuilderAddNode(dockspace_id_a, ImGuiDockNodeFlags_DockSpace); // Add empty node
		ImGui::DockBuilderSetNodeSize(dockspace_id_a, dockspace_size);

		auto dock_id_top = dockspace_id_a;
		const auto dock_id_bottom = ImGui::DockBuilderSplitNode(dock_id_top, ImGuiDir_Down, 0.50F, nullptr, &dock_id_top);

		ImGui::DockBuilderDockWindow("Prefabs", dock_id_top);
		ImGui::DockBuilderDockWindow("Preferences", dock_id_bottom);
		ImGui::DockBuilderFinish(dockspace_id_a);
	}
	ImGui::DockSpace(dockspace_id_a, ImVec2(0, 0), ImGuiDockNodeFlags_PassthruCentralNode);
	ImGui::End();

	ImGui::SetNextWindowPos(ImVec2(m_renderSize.x - (m_renderSize.x / 5.0F), 0), ImGuiCond_Appearing);
	ImGui::SetNextWindowSize(dockspace_size, ImGuiCond_Appearing);
	ImGui::Begin("Docking Area B", nullptr, window_flags);
	const auto dockspace_id_b = ImGui::GetID("Docking Space B");
	if (ImGui::DockBuilderGetNode(dockspace_id_b) == nullptr) {
		ImGui::DockBuilderRemoveNode(dockspace_id_b); // Clear out existing layout
		ImGui::DockBuilderAddNode(dockspace_id_b, ImGuiDockNodeFlags_DockSpace); // Add empty node
		ImGui::DockBuilderSetNodeSize(dockspace_id_b, dockspace_size);

		auto dock_id_top = dockspace_id_b;
		const auto dock_id_bottom = ImGui::DockBuilderSplitNode(dock_id_top, ImGuiDir_Down, 0.50F, nullptr, &dock_id_top);

		ImGui::DockBuilderDockWindow("Scene Inspector", dock_id_top);
		ImGui::DockBuilderDockWindow("Entity Inspector", dock_id_bottom);
		ImGui::DockBuilderFinish(dockspace_id_b);
	}
	ImGui::DockSpace(dockspace_id_b, ImVec2(0, 0), ImGuiDockNodeFlags_PassthruCentralNode);
	ImGui::End();
	ImGui::PopStyleVar();
	ImGui::PopStyleVar();

	// Process all UI elements
	const auto elements = {
		m_uiHotkeys,m_uiCamController,m_uiRotIndicator,m_uiTitlebar,m_uiPrefabs,m_uiSceneInspector,m_uiEntityInspector,m_uiSettings,m_uiRecoverDialogue,m_uiOpenDialogue,m_uiSaveDialogue,m_uiUnsavedDialogue,m_uiMissingDialogue,
	};
	for (auto& element : elements)
		element->tick(deltaTime);

	// Rendering
	ImGui::Render();
	ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
}

void ImGUI_Element::open() noexcept
{
	m_open = true;
}

void ImGUI_Element::close() noexcept
{
	m_open = false;
}

void ImGUI_Element::tick(const float& /*unused*/)
{
}


text:
#define GENUS X(rdft_hb_genus)
extern const hc2hc_genus GENUS;


text:
<!DOCTYPE html>

	<meta charset="utf-8">

	<title>IFIndoorLocationManager Class Reference</title>

	<link rel="stylesheet" href="../css/style.css">
	<meta name="viewport" content="initial-scale=1, maximum-scale=1.4">
	<meta name="generator" content="appledoc 2.2.1 (build 1334)">

				ifinitySDK

				Ifinity

Index

Hierarchy

							On This Page

							<select id="jump-to">
	<option value="top">Jump To…</option>

	<option value="overview">Overview</option>

	<option value="tasks">Tasks</option>

	<optgroup label="Properties">

		<option value="//api/name/currentLocation">currentLocation</option>

	</optgroup>

	<optgroup label="Instance Methods">

		<option value="//api/name/currentArea">- currentArea</option>

		<option value="//api/name/initWithBluetoothManager:">- initWithBluetoothManager:</option>

		<option value="//api/name/startCheckingAreasForFloorplan:">- startCheckingAreasForFloorplan:</option>

		<option value="//api/name/startUpdatingIndoorLocation">- startUpdatingIndoorLocation</option>

		<option value="//api/name/stopCheckingAreas">- stopCheckingAreas</option>

		<option value="//api/name/stopUpdatingIndoorLocation">- stopUpdatingIndoorLocation</option>

	</optgroup>

</select>

IFIndoorLocationManager Class Reference

	Inherits from
	NSObject

	Declared in
	IFIndoorLocationManager.h

Overview

The IFIndoorLocationManager class is central point for delivering information about indoor device position.

  currentLocation

Current user position (indoors)

@property (nonatomic, readonly) CLLocation *currentLocation

Discussion

Current user position (indoors)

Declared In

IFIndoorLocationManager.h

– initWithBluetoothManager:

shared instance of IFBluetoothManager

- (instancetype)initWithBluetoothManager:(IFBluetoothManager *)manager

Discussion

shared instance of IFBluetoothManager

Declared In

IFIndoorLocationManager.h

– startUpdatingIndoorLocation

Once we want to be notified about user indoor position updates

- (void)startUpdatingIndoorLocation

Discussion

Once we want to be notified about user indoor position updates

Declared In

IFIndoorLocationManager.h

– stopUpdatingIndoorLocation

Shuts down the indoor monitoring process

- (void)stopUpdatingIndoorLocation

Discussion

Shuts down the indoor monitoring process

Declared In

IFIndoorLocationManager.h

– startCheckingAreasForFloorplan:

Start detecting current area base on calculated position. When area changed notify about it by calling methods in delegate (didEnterArea, didExitArea).

- (void)startCheckingAreasForFloorplan:(IFMFloorplan *)floorplan

Parameters

						floorplan

A floorplan we’re interested in

Discussion

Start detecting current area base on calculated position. When area changed notify about it by calling methods in delegate (didEnterArea, didExitArea).

Declared In

IFIndoorLocationManager.h

– stopCheckingAreas

Stop checking areas for current position.

- (void)stopCheckingAreas

Discussion

Stop checking areas for current position.

Declared In

IFIndoorLocationManager.h

– currentArea

Current area base on position

- (IFMArea *)currentArea

Return Value

area model object

Discussion

Current area base on position

Declared In

IFIndoorLocationManager.h

Copyright © 2015 Ifinity. All rights reserved. Updated: 2015-10-22

Generated by appledoc 2.2.1 (build 1334).


text:
package org.wso2.carbon.event.processor.core.util;

public final class DistributedModeConstants {

    public static final String STORM_STATUS_MAP = "org.wso2.cep.org.wso2.carbon.event.processor.core.storm.status.execution.plan.ui";

    /**
     * These states are different to the states in Storm terminology, except for ACTIVE
     */
    public enum TopologyState{
        UNKNOWN,            //Topology status has not been queried yet from Storm.
        CLEANING,           //StormTopologyManager is cleaning an existing topology with the same name, to deploy this topology.
        DEPLOYING,          //StormTopologyManager is in the process of deploying this  topology
        ACTIVE,             //Indicates that the topology was found to be in ACTIVE state (as in Storm terminology) in the storm cluster.
    }
}


text:
package weixin.popular.support;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import weixin.popular.api.TokenAPI;
import weixin.popular.bean.token.Token;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.*;

/**
 * TokenManager token 自动刷新
 *
 * @author LiYi
 */
public class TokenManager {

    private static final Logger logger = LoggerFactory.getLogger(TokenManager.class);

    private static ScheduledExecutorService scheduledExecutorService;

    private static Map<String, String> tokenMap = new LinkedHashMap<String, String>();

    private static Map<String, ScheduledFuture<?>> futureMap = new HashMap<String, ScheduledFuture<?>>();

    private static int poolSize = 2;

    private static boolean daemon = Boolean.TRUE;

    /**
     * 初始化 scheduledExecutorService
     */
    private static void initScheduledExecutorService() {
        logger.info("daemon:{},poolSize:{}", daemon, poolSize);
        scheduledExecutorService = Executors.newScheduledThreadPool(poolSize, new ThreadFactory() {

            @Override
            public Thread newThread(Runnable arg0) {
                Thread thread = Executors.defaultThreadFactory().newThread(arg0);
                //设置守护线程
                thread.setDaemon(daemon);
                return thread;
            }
        });
    }

    /**
     * 设置线程池
     *
     * @param poolSize poolSize
     */
    public static void setPoolSize(int poolSize) {
        TokenManager.poolSize = poolSize;
    }

    /**
     * 设置线程方式
     *
     * @param daemon daemon
     */
    public static void setDaemon(boolean daemon) {
        TokenManager.daemon = daemon;
    }

    /**
     * 初始化token 刷新,每118分钟刷新一次。
     *
     * @param appid  appid
     * @param secret secret
     */
    public static void init(final String appid, final String secret) {
        if (scheduledExecutorService == null) {
            initScheduledExecutorService();
        }
        if (futureMap.containsKey(appid)) {
            futureMap.get(appid).cancel(true);
        }
        ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                Token token = TokenAPI.token(appid, secret);
                tokenMap.put(appid, token.getAccess_token());
                logger.info("ACCESS_TOKEN refurbish with appid:{}", appid);
            }
        }, 0, 118, TimeUnit.MINUTES);
        futureMap.put(appid, scheduledFuture);
        logger.info("appid:{}", appid);
    }

    /**
     * 取消 token 刷新
     */
    public static void destroyed() {
        scheduledExecutorService.shutdownNow();
        logger.info("destroyed");
    }

    /**
     * 获取 access_token
     *
     * @param appid appid
     * @return token
     */
    public static String getToken(String appid) {
        return tokenMap.get(appid);
    }

    /**
     * 获取第一个appid 的 access_token
     * 适用于单一微信号
     *
     * @return token
     */
    public static String getDefaultToken() {
        Object[] objs = tokenMap.values().toArray();
        return objs.length > 0 ? objs[0].toString() : null;
    }

}


text:
// Copyright (C) 2008 Google Inc.
//
// 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.

/**
 * @fileoverview
 * Registers a language handler for OCaml, SML, F# and similar languages.
 *
 * Based on the lexical grammar at
 * http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html#_Toc270597388
 *
 * @author mikesamuel@gmail.com
 */

PR['registerLangHandler'](
    PR['createSimpleLexer'](
        [
         // Whitespace is made up of spaces, tabs and newline characters.
         [PR['PR_PLAIN'],       /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0'],
         // #if ident/#else/#endif directives delimit conditional compilation
         // sections
         [PR['PR_COMMENT'],
          /^#(?:if[\t\n\r \xA0]+(?:[a-z_$][\w\']*|``[^\r\n\t`]*(?:``|$))|else|endif|light)/i,
          null, '#'],
         // A double or single quoted, possibly multi-line, string.
         // F# allows escaped newlines in strings.
         [PR['PR_STRING'],      /^(?:\"(?:[^\"\\]|\\[\s\S])*(?:\"|$)|\'(?:[^\'\\]|\\[\s\S])(?:\'|$))/, null, '"\'']
        ],
        [
         // Block comments are delimited by (* and *) and may be
         // nested. Single-line comments begin with // and extend to
         // the end of a line.
         // TODO: (*...*) comments can be nested.  This does not handle that.
         [PR['PR_COMMENT'],     /^(?:\/\/[^\r\n]*|\(\*[\s\S]*?\*\))/],
         [PR['PR_KEYWORD'],     /^(?:abstract|and|as|assert|begin|class|default|delegate|do|done|downcast|downto|elif|else|end|exception|extern|false|finally|for|fun|function|if|in|inherit|inline|interface|internal|lazy|let|match|member|module|mutable|namespace|new|null|of|open|or|override|private|public|rec|return|static|struct|then|to|true|try|type|upcast|use|val|void|when|while|with|yield|asr|land|lor|lsl|lsr|lxor|mod|sig|atomic|break|checked|component|const|constraint|constructor|continue|eager|event|external|fixed|functor|global|include|method|mixin|object|parallel|process|protected|pure|sealed|trait|virtual|volatile)\b/],
         // A number is a hex integer literal, a decimal real literal, or in
         // scientific notation.
         [PR['PR_LITERAL'],
          /^[+\-]?(?:0x[\da-f]+|(?:(?:\.\d+|\d+(?:\.\d*)?)(?:e[+\-]?\d+)?))/i],
         [PR['PR_PLAIN'],       /^(?:[a-z_][\w']*[!?#]?|``[^\r\n\t`]*(?:``|$))/i],
         // A printable non-space non-special character
         [PR['PR_PUNCTUATION'], /^[^\t\n\r \xA0\"\'\w]+/]
        ]),
    ['fs', 'ml']);


text:
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Markup;
using System.Windows.Media;
using System.Xml;

namespace StructuredXmlEditor.View
{
	public class ColourMarkupConverter : ConverterBase
	{
		private static Dictionary<string, Brush> colourBrushMap = new Dictionary<string, Brush>();

		protected override object Convert(object i_value, Type i_targetType, object i_parameter, CultureInfo i_culture)
		{
			string input = i_value as string;
			if (!string.IsNullOrWhiteSpace(input))
			{
				var textBlock = new TextBlock();
				textBlock.Background = Brushes.Transparent;
				textBlock.TextTrimming = TextTrimming.CharacterEllipsis;

				string currentString = "";
				bool inTag = false;
				Stack<string> colour = new Stack<string>();
				colour.Push("255,255,255");
				bool tagIsClosing = false;

				for (int i = 0; i < input.Length; i++)
				{
					var c = input[i];

					if (c == '<')
					{
						Flush(textBlock, currentString, colour.Peek());
						currentString = "";

						inTag = true;
					}
					else if (c == '/' && inTag)
					{
						tagIsClosing = true;
					}
					else if (c == '>' && inTag)
					{
						if (tagIsClosing)
						{
							colour.Pop();
						}
						else
						{
							if (currentString == "---")
							{
								colour.Push(colour.Peek());
							}
							else
							{
								colour.Push(currentString);
							}
						}

						tagIsClosing = false;
						inTag = false;
						currentString = "";
					}
					else
					{
						currentString += c;
					}
				}

				Flush(textBlock, currentString, colour.Peek());

				return textBlock;
			}

			return null;
		}

		private void Flush(TextBlock block, string text, string current)
		{
			if (text == "") return;

			if (!colourBrushMap.ContainsKey(current))
			{
				var col = current.ToColour().Value;
				var brush = new SolidColorBrush(col);
				brush.Freeze();

				colourBrushMap[current] = brush;
			}

			block.Inlines.Add(new Run(text) { Foreground = colourBrushMap[current] });
		}
	}
}


text:
from six import iteritems

class BaseError(Exception):

    def __init__(self, messages):
        if not isinstance(messages, (list, tuple, dict)):
            messages = [messages]

        clean_messages = self.clean_messages(messages)

        Exception.__init__(self, clean_messages)
        self.messages = clean_messages

    def clean_messages(self, messages):
        if isinstance(messages, dict):
            clean_messages = {}
            for key, value in iteritems(messages):
                if isinstance(value, ValidationError):
                    value = value.messages
                clean_messages[key] = value
        else:
            clean_messages = []
            for message in messages:
                if isinstance(message, ValidationError):
                    message = message.messages
                clean_messages.append(message)

        return clean_messages

class ConversionError(BaseError, TypeError):

    """ Exception raised when data cannot be converted to the correct python type """
    pass

class ModelConversionError(ConversionError):
    pass

class ValidationError(BaseError, ValueError):

    """Exception raised when invalid data is encountered."""
    pass

class ModelValidationError(ValidationError):
    pass

class StopValidation(ValidationError):

    """Exception raised when no more validation need occur."""
    pass

class MockCreationError(ValueError):
    """Exception raised when a mock value cannot be generated."""
    pass


text:
package com.bitmechanic.barrister;

public class Doctor extends Person {

    private Double years;

    public Double getYearsInPractice() { return years; }
    public void setYearsInPractice(Double d) { years = d; }

}


text:
Magic League Website

    <login-view></login-view>
    <member-season-view></member-season-view>


text:
Package to generate reports with JasperReports library through  RESTful API JSON.

# JasperReports for NodeJs

Package to generate reports with [JasperReports](http://community.jaspersoft.com/project/jasperreports-library) library through [JasperStarter](http://jasperstarter.sourceforge.net/) command-line tool.
##Requirements

Yo need install on your server

Java version "1.6.0" or latest.
Java(TM) SE Runtime Environment.
Java HotSpot(TM) 64-Bit Server VM.

## next activitys

-Admin jrxml and Jasper Documents
	Upload
	Compile
	Process

##Introduction

This package aims to be a solution to compile and process JasperReports (.jrxml & .jasper files).

This project start 3-Feb-2015 and finalize to i dont know..

##License

MIT


text:
"use strict";

var NodeBB = require('./lib/nodebb'),
	UploadsController = NodeBB.UploadsController,
	ControllerHelpers = NodeBB.ControllerHelpers,

	Config = require('./lib/config'),
	Gallery = require('./lib/gallery'),

	async = require('async'),

	GroupGallery = {},
	app;

GroupGallery.init = function(params, callback) {
	var router = params.router,
		middleware = params.middleware,
		multipartMiddleware = require('connect-multiparty')();

	router.get('/groups/:name/gallery', middleware.checkGlobalPrivacySettings, middleware.buildHeader,
		groupExists, renderImages);
	router.get('/groups/:name/gallery/:image_id', middleware.checkGlobalPrivacySettings, middleware.buildHeader,
		groupExists, increaseViewCount, renderSingleImage);
	router.get('/api/groups/:name/gallery', middleware.checkGlobalPrivacySettings,
		groupExists, renderImages);
	router.get('/api/groups/:name/gallery/:image_id', middleware.checkGlobalPrivacySettings,
		groupExists, increaseViewCount, renderSingleImage);

	router.post('/groups/:name/gallery/upload', multipartMiddleware, middleware.applyCSRF,
		middleware.authenticate, middleware.checkGlobalPrivacySettings, groupExists, uploadImage);

	NodeBB.SocketAdmin[Config.plugin.id] = Config.adminSockets;
	NodeBB.SocketPlugins[Config.plugin.id] = require('./lib/sockets');

	app = params.app;

	Config.init(callback);
};

GroupGallery.defineWidget = function(widgets, callback) {
	widgets.push({
		name: Config.plugin.name,
		widget: Config.plugin.id,
		description: Config.plugin.description,
		content: ''
	});

	callback(null, widgets);
};

GroupGallery.renderWidget = function(widget, callback) {
	if (widget.area.template.indexOf('groups') === 0) {
		var parts = decodeURIComponent(widget.area.url).split('/');
		if (Array.isArray(parts) && parts.length) {
			// I have been assured by baris and julian that this is solid enough.
			var groupName = parts[parts.length - 1];
			Gallery.getImagesByGroupName(groupName, 0, 2, function(err, images) {
				app.render('group-gallery/widget', {images: images}, callback);
			});
		} else {
			callback(null, '
An error occurred trying to render this widget.
');
		}
	} else {
		NodeBB.User.isAdministrator(widget.uid, function(err, isAdmin) {
			var html = '';
			if (isAdmin) {
				html = '
The Group Gallery widget only works on group pages.
» Widget settings
';
			}

			callback(null, html);
		});
	}
};

GroupGallery.groupRename = function(data) {
	Gallery.renameGroup(data.old, data.new);
};

function renderImages(req, res, next) {
	var imagesPerPage = 4,
		uid = req.query.uid && req.query.uid.length ? parseInt(req.query.uid, 10) : 0;

	async.waterfall([
		function(next) {
			if (!isNaN(uid) && uid > 0) {
				Gallery.getGroupImageCountByUid(req.params.name, uid, next);
			} else {
				Gallery.getGroupImageCount(req.params.name, next);
			}
		},
		function(imageCount, next) {
			var pageCount = Math.max(1, Math.ceil(imageCount / imagesPerPage));

			if (req.query.page < 1 || req.query.page > pageCount) {
				return ControllerHelpers.notFound(req, res);
			}

			var page = parseInt(req.query.page, 10) || 1;
			var start = (page - 1) * imagesPerPage,
				end = start + imagesPerPage - 1;

			async.parallel({
				images: function(next) {
					if (!isNaN(uid) && uid > 0) {
						Gallery.getImagesByUid(req.params.name, uid, start, end, next);
					} else {
						Gallery.getImagesByGroupName(req.params.name, start, end, next);
					}
				},
				group: function(next) {
					NodeBB.Groups.getGroupNameByGroupSlug(req.params.name, function(err, groupName) {
						NodeBB.Groups.get(groupName, {}, next);
					});
				}
			}, function(err, results) {
				next(err, {
					pageCount: pageCount,
					currentPage: page,
					images: results.images,
					group: results.group
				});
			});
		}
	], function(err, data) {
		data.pagination = NodeBB.Pagination.create(data.currentPage, data.pageCount);
		res.render('group-gallery/gallery', data);
	});
}

function renderSingleImage(req, res, next) {
	var id = parseInt(req.params.image_id, 10);
	if (isNaN(id)) {
		next(new Error('invalid-image'));
	} else {
		Gallery.getImagesByIds([id], function(err, image) {
			if (err || !image.length) {
				next(new Error('invalid-image'));
			} else {
				image = image[0];

				async.parallel({
					nextImages: function(next) {
						// Get the next 3 images
						NodeBB.db.getSortedSetRangeByScore(
							'group-gallery:group:' + req.params.name + ':images',
							1, 3, image.timestamp, Date.now(),
							function(err, result) {
								Gallery.getImagesByIds(result, next);
							}
						);
					},
					prevId: function(next) {
						// Get the previous image
						NodeBB.db.getSortedSetRangeByScore(
							'group-gallery:group:' + req.params.name + ':images',
							0, 0, 0, image.timestamp - 1,
							function(err, result) {
								next(null, result.length ? parseInt(result[result.length - 1], 10) : null);
							}
						);
					},
					group: function(next) {
						NodeBB.Groups.getGroupNameByGroupSlug(req.params.name, function(err, groupName) {
							NodeBB.Groups.get(groupName, {}, next);
						});
					}
				}, function(err, result) {
					if (err) {
						next(new Error('invalid-image'));
					} else {
						result.image = image;
						result.nextId = result.nextImages.length ? result.nextImages[0].id : null;
						res.render('group-gallery/single', result);
					}
				});
			}
		});
	}
}

function increaseViewCount(req, res, next) {
	var id = parseInt(req.params.image_id, 10);
	if (isNaN(id)) {
		next(new Error('invalid-image'));
	} else {
		Gallery.increaseViewCount(id, function(err, result) {
			next();
		});
	}
}

function uploadImage(req, res, next) {
	UploadsController.upload(req, res, function(file, next) {
		var params = JSON.parse(req.body.params);
		if (params && params.caption && params.caption.length && NodeBB.Plugins.hasListeners('filter:uploadImage')) {
			NodeBB.Plugins.fireHook('filter:uploadImage', {image: file, uid: req.user.uid}, function(err, data) {
				if (err) {
					return next(err);
				}

				Gallery.addImage({
					uid: req.user.uid,
					url: data.url,
					group: req.params.name,
					caption: params.caption
				}, function(err, image) {
					NodeBB.SocketIndex.server.sockets.emit('event:group-gallery.newImage', image);
					next(err, data);
				});
			});
		} else {
			next(new Error('no-upload-plugin'))
		}
	}, next);
}

function groupExists(req, res, next) {
	NodeBB.Groups.exists(req.params.name, function(err, exists) {
		if (err || !exists) {
			ControllerHelpers.notFound(req, res);
		} else {
			next();
		}
	});
}

module.exports = GroupGallery;


text:
class InfoController < ApplicationController
  def daten
  end

  def mitmachen
  end

  def kontakt
  end

  def datenschutz
  end

  def spenden
  end

  def index
  end

  def stilllegung
  end
end


text:
package com.facebook.buck.util;

/** A crappy version of {@link org.apache.commons.math3.stat.descriptive.SummaryStatistics}. */
// We'd love to use commons-math's SummaryStatistics, but commons-math is 2.5MB.
// For algorithm, see
// https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
public class Statistics {
  long count = 0;
  double mean = 0;
  double m2 = 0;

  /** Add a value to the data. */
  public void addValue(long millis) {
    count += 1;
    double delta = millis - mean;
    mean += delta / count;
    double delta2 = millis - mean;
    m2 += delta2 * delta;
  }

  /** Get the count of values. */
  public long getN() {
    return count;
  }

  /** Get the mean. */
  public double getMean() {
    return mean;
  }

  /** Get the standard deviation. */
  public double getVariance() {
    return m2 / (getN() - 1);
  }

  /** Get the standard deviation. */
  public double getStandardDeviation() {
    return Math.sqrt(getVariance());
  }

  /**
   * Get the 97.5% z-score. [ getMean() - getZScore(), getMean() + getZscore()] gives approximately
   * a nice 95% confidence interval for the mean.
   */
  public double getConfidenceIntervalOffset() {
    // See https://en.wikipedia.org/wiki/1.96 and
    // http://www.stat.yale.edu/Courses/1997-98/101/confint.htm

    // I don't think this is quite correct, the value should be based on N, but that's okay it's
    // close enough.
    return 1.96 * getStandardDeviation() / Math.sqrt(getN());
  }
}


text:
namespace Fpm.ProfileData.Entities.LookUps
{
    public class Sex
    {
        public int SexID { get; set; }
        public string Description { get; set; }
    }
}


text:
struct MediaGalleryPrefInfo;

namespace views {
class ButtonListener;
class Checkbox;
class ContextMenuController;
class Label;
}  // namespace views

// A view composed of a checkbox, optional folder icon button, and secondary
// text that will elide to its parent's width. Used by
// MediaGalleriesDialogViews.
class MediaGalleryCheckboxView : public views::View {
 public:
  MediaGalleryCheckboxView(const MediaGalleryPrefInfo& pref_info,
                           int trailing_vertical_space,
                           views::ButtonListener* button_listener,
                           views::ContextMenuController* menu_controller);
  ~MediaGalleryCheckboxView() override;

  // Overrides from views::View.
  void Layout() override;

  views::Checkbox* checkbox() { return checkbox_; }
  views::Label* secondary_text() { return secondary_text_; }

 private:
  // Owned by the parent class (views::View).
  views::Checkbox* checkbox_;
  views::Label* secondary_text_;

  DISALLOW_COPY_AND_ASSIGN(MediaGalleryCheckboxView);
};

#endif  // CHROME_BROWSER_UI_VIEWS_EXTENSIONS_MEDIA_GALLERY_CHECKBOX_VIEW_H_


text:
<?php

namespace Grido\Components\Columns;

/**
 * Email column.
 *
 * @package     Grido
 * @subpackage  Components\Columns
 * @author      Petr Bugyík
 */
class Email extends Link
{
    /**
     * @param string $value
     * @return string
     */
    protected function formatHref($value)
    {
        return "mailto:" . $value;
    }

    /**
     * @param mixed $value
     * @return \Nette\Utils\Html
     */
    protected function getAnchor($value)
    {
        $anchor = parent::getAnchor($value);
        unset($anchor->attrs['target']);
        unset($anchor->attrs['rel']);

        return $anchor;
    }
}


text:
from __future__ import absolute_import

import salt.pillar
import salt.wheel
import requests

import logging
log = logging.getLogger(__name__)

def process_minion_request(minion_id, url="http://localhost:8001/workernode?state=1"):
    try:
        r = requests.get(url)
    except:
        log.error("Error when connecting to Dynamic Cluster.")
        return False
    else:
        wns=r.json()
        log.debug("wns %s" % wns)
        starting_ids=[wn['instance']['instance_name'] for wn in wns]
        wheel = salt.wheel.Wheel(__opts__)
        if minion_id in starting_ids:
            wheel.call_func('key.accept', match=minion_id)
        else:
            wheel.call_func('key.reject', match=minion_id)
        return True


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ICSharpCode.SharpZipLib.Zip;
using PackageToNuget.UmbracoDefinitions;

namespace PackageToNuget
{
    public class PackageReader
    {
        private readonly string path;

        public PackageReader(string path)
        {
            this.path = path;
        }

        public PackageDefinition ReadDefinition()
        {
            using (var zipFile = new ZipFile(path))
            {
                return ReadDefinition(zipFile);
            }
        }

        internal static PackageDefinition ReadDefinition(ZipFile zipFile)
        {
            var entry = FindPackageXml(zipFile);
            using (var stream = zipFile.GetInputStream(entry))
            {
                return PackageDefinition.Load(stream);
            }
        }

        public static ZipEntry FindPackageXml(ZipFile zipFile)
        {
            foreach(ZipEntry entry in zipFile)
                if (entry.Name.EndsWith("package.xml", StringComparison.OrdinalIgnoreCase))
                    return entry;
            return null;
        }
    }
}


text:
const Archiver = require("archiver");
const fs = require("fs");
let version = "2.5";

if (process.env.TRAVIS_BUILD_NUMBER) {
    version = `${version}.${process.env.TRAVIS_BUILD_NUMBER}`;
} else {
    version = `${version}.0-SNAPSHOT`
}

const path = `${__dirname}/dist/JAlgoArena-UI-${version}.zip`;
const output = fs.createWriteStream(path);
const archive = new Archiver("zip", {store: true});

archive.on("error", function(err) {
    throw err;
});

archive.pipe(output);
archive.directory("./build/", false);
archive.finalize();


text:
from pysqlite2 import dbapi2 as sqlite3
import re, json

def read_charges(sqlite_db='ccj'):

    """
        Assumes the SQL table 'chargeshistory' exists, with at least a
        citation column in it, basically in the format of the data found at:
        "http://cookcountyjail.recoveredfactory.net/api/1.0/chargeshistory/?format=json".

    """

    conn = sqlite3.connect(sqlite_db)
    c = conn.cursor()

    # get the size of the table
    c.execute('SELECT COUNT(*) FROM countyapi_chargeshistory')
    for result in c:
        size = float(result[0])

    c.execute("SELECT charges_citation FROM countyapi_chargeshistory;")

    charges = []

    for row in c:
        if row[0] is not None:
            charges.append(row[0])

    return charges

def normalize(all_charges=None):

    """
        Returns a tuple containing:

        - a list of unique, normalized citations,
        - a list of unqiue citations that couldn't be handled    """

    CHARGE_REGEX = \
        ('(\d{1,3})'                 # - Chapter
        ' ILCS '                     #
        '(\d{1,4})'                  # - Act
        '[ |/]'                      #
        '(\d{1,4}'                   # - Section
        '(?:[ |-]\d{1,4}\w?)?'       # - Section, cont.
        '(?:\.\d)?)'                 # - Section, cont.
        '((?:\([\w|\-|.]\)){0,4})?'  # - optional sub-sections
        '.*')                        #

    CHARGE_PATTERN = re.compile(CHARGE_REGEX)

    if not all_charges:
        all_charges = read_charges()

    uniq_charges = set([])
    total_fail = 0
    uniq_fail = set([])

    for charge in all_charges:

        match = CHARGE_PATTERN.match(charge)

        if match:

            chapter = match.group(1)
            act = match.group(2)
            section = match.group(3)
            subsection = match.group(4)

            citation = "{0} {1}/{2}{3}".format(chapter, act, section, subsection)
            uniq_charges.add(citation)

        else:
            total_fail += 1
            uniq_fail.add(charge)

    return list(uniq_charges), list(uniq_fail)

def write_migration(filename, charges=None, sqlite_db='ccj'):

    """ Serializes the normalized charges data in a json file with
        the supplied name. """

    if not charges:
        charges, _ = normalize()

    with open(filename, 'w') as migration_file:
        json.dump(charges, migration_file, indent=0)

    print "{0} citations added to the migration".format(len(charges))


text:
namespace GLnexus {
namespace diploid {

unsigned genotypes(unsigned n_allele);

std::pair<unsigned,unsigned> gt_alleles(unsigned gt);
unsigned alleles_gt(unsigned a1, unsigned a2);

// Extract genotype log-likelihoods, or Status::NOT_FOUND
Status bcf_get_genotype_log_likelihoods(const bcf_hdr_t* header, bcf1_t *record, std::vector<double>& gll);

// Find zygosity_by_GQ for each allele based on the GT and GQ of the record in
// specified samples. (see types.h for the definition of zygosity_by_GQ)
Status bcf_zygosity_by_GQ(const bcf_hdr_t* header, bcf1_t* record, const std::vector<unsigned>& samples,
                          std::vector<zygosity_by_GQ>& ans);

// This function finds the maximum AQs for each allele in the record, across the given
// subset of sample indices. (see types.h for the definition of AQ)
Status bcf_alleles_topAQ(const bcf_hdr_t* hdr, bcf1_t* record, const std::vector<unsigned>& samples,
                         std::vector<top_AQ>& ans);

// exposed for testing: find alleles' maxAQ for given multi-sample genotype likelihood
// vector
Status alleles_topAQ(unsigned n_allele, unsigned n_sample, const std::vector<unsigned>& samples,
                     const std::vector<double>& gl, std::vector<top_AQ>& ans);

namespace trio {
int mendelian_inconsistencies(int gt_p1, int gt_p2, int gt_ch);
}

}}


text:
require 'Fedora-API-M-WSDLDriver.rb'

endpoint_url = ARGV.shift
obj = FedoraAPIM.new(endpoint_url)

# run ruby with -d to see SOAP wiredumps.
obj.wiredump_dev = STDERR if $DEBUG

# SYNOPSIS
#   ingest(parameters)
#
# ARGS
#   parameters      Ingest - {http://www.fedora.info/definitions/1/0/types/}ingest
#
# RETURNS
#   parameters      IngestResponse - {http://www.fedora.info/definitions/1/0/types/}ingestResponse
#
parameters = nil
puts obj.ingest(parameters)

# SYNOPSIS
#   modifyObject(parameters)
#
# ARGS
#   parameters      ModifyObject - {http://www.fedora.info/definitions/1/0/types/}modifyObject
#
# RETURNS
#   parameters      ModifyObjectResponse - {http://www.fedora.info/definitions/1/0/types/}modifyObjectResponse
#
parameters = nil
puts obj.modifyObject(parameters)

# SYNOPSIS
#   getObjectXML(parameters)
#
# ARGS
#   parameters      GetObjectXML - {http://www.fedora.info/definitions/1/0/types/}getObjectXML
#
# RETURNS
#   parameters      GetObjectXMLResponse - {http://www.fedora.info/definitions/1/0/types/}getObjectXMLResponse
#
parameters = nil
puts obj.getObjectXML(parameters)

# SYNOPSIS
#   export(parameters)
#
# ARGS
#   parameters      Export - {http://www.fedora.info/definitions/1/0/types/}export
#
# RETURNS
#   parameters      ExportResponse - {http://www.fedora.info/definitions/1/0/types/}exportResponse
#
parameters = nil
puts obj.export(parameters)

# SYNOPSIS
#   purgeObject(parameters)
#
# ARGS
#   parameters      PurgeObject - {http://www.fedora.info/definitions/1/0/types/}purgeObject
#
# RETURNS
#   parameters      PurgeObjectResponse - {http://www.fedora.info/definitions/1/0/types/}purgeObjectResponse
#
parameters = nil
puts obj.purgeObject(parameters)

# SYNOPSIS
#   addDatastream(parameters)
#
# ARGS
#   parameters      AddDatastream - {http://www.fedora.info/definitions/1/0/types/}addDatastream
#
# RETURNS
#   parameters      AddDatastreamResponse - {http://www.fedora.info/definitions/1/0/types/}addDatastreamResponse
#
parameters = nil
puts obj.addDatastream(parameters)

# SYNOPSIS
#   modifyDatastreamByReference(parameters)
#
# ARGS
#   parameters      ModifyDatastreamByReference - {http://www.fedora.info/definitions/1/0/types/}modifyDatastreamByReference
#
# RETURNS
#   parameters      ModifyDatastreamByReferenceResponse - {http://www.fedora.info/definitions/1/0/types/}modifyDatastreamByReferenceResponse
#
parameters = nil
puts obj.modifyDatastreamByReference(parameters)

# SYNOPSIS
#   modifyDatastreamByValue(parameters)
#
# ARGS
#   parameters      ModifyDatastreamByValue - {http://www.fedora.info/definitions/1/0/types/}modifyDatastreamByValue
#
# RETURNS
#   parameters      ModifyDatastreamByValueResponse - {http://www.fedora.info/definitions/1/0/types/}modifyDatastreamByValueResponse
#
parameters = nil
puts obj.modifyDatastreamByValue(parameters)

# SYNOPSIS
#   setDatastreamState(parameters)
#
# ARGS
#   parameters      SetDatastreamState - {http://www.fedora.info/definitions/1/0/types/}setDatastreamState
#
# RETURNS
#   parameters      SetDatastreamStateResponse - {http://www.fedora.info/definitions/1/0/types/}setDatastreamStateResponse
#
parameters = nil
puts obj.setDatastreamState(parameters)

# SYNOPSIS
#   setDatastreamVersionable(parameters)
#
# ARGS
#   parameters      SetDatastreamVersionable - {http://www.fedora.info/definitions/1/0/types/}setDatastreamVersionable
#
# RETURNS
#   parameters      SetDatastreamVersionableResponse - {http://www.fedora.info/definitions/1/0/types/}setDatastreamVersionableResponse
#
parameters = nil
puts obj.setDatastreamVersionable(parameters)

# SYNOPSIS
#   compareDatastreamChecksum(parameters)
#
# ARGS
#   parameters      CompareDatastreamChecksum - {http://www.fedora.info/definitions/1/0/types/}compareDatastreamChecksum
#
# RETURNS
#   parameters      CompareDatastreamChecksumResponse - {http://www.fedora.info/definitions/1/0/types/}compareDatastreamChecksumResponse
#
parameters = nil
puts obj.compareDatastreamChecksum(parameters)

# SYNOPSIS
#   getDatastream(parameters)
#
# ARGS
#   parameters      GetDatastream - {http://www.fedora.info/definitions/1/0/types/}getDatastream
#
# RETURNS
#   parameters      GetDatastreamResponse - {http://www.fedora.info/definitions/1/0/types/}getDatastreamResponse
#
parameters = nil
puts obj.getDatastream(parameters)

# SYNOPSIS
#   getDatastreams(parameters)
#
# ARGS
#   parameters      GetDatastreams - {http://www.fedora.info/definitions/1/0/types/}getDatastreams
#
# RETURNS
#   parameters      GetDatastreamsResponse - {http://www.fedora.info/definitions/1/0/types/}getDatastreamsResponse
#
parameters = nil
puts obj.getDatastreams(parameters)

# SYNOPSIS
#   getDatastreamHistory(parameters)
#
# ARGS
#   parameters      GetDatastreamHistory - {http://www.fedora.info/definitions/1/0/types/}getDatastreamHistory
#
# RETURNS
#   parameters      GetDatastreamHistoryResponse - {http://www.fedora.info/definitions/1/0/types/}getDatastreamHistoryResponse
#
parameters = nil
puts obj.getDatastreamHistory(parameters)

# SYNOPSIS
#   purgeDatastream(parameters)
#
# ARGS
#   parameters      PurgeDatastream - {http://www.fedora.info/definitions/1/0/types/}purgeDatastream
#
# RETURNS
#   parameters      PurgeDatastreamResponse - {http://www.fedora.info/definitions/1/0/types/}purgeDatastreamResponse
#
parameters = nil
puts obj.purgeDatastream(parameters)

# SYNOPSIS
#   getNextPID(parameters)
#
# ARGS
#   parameters      GetNextPID - {http://www.fedora.info/definitions/1/0/types/}getNextPID
#
# RETURNS
#   parameters      GetNextPIDResponse - {http://www.fedora.info/definitions/1/0/types/}getNextPIDResponse
#
parameters = nil
puts obj.getNextPID(parameters)

# SYNOPSIS
#   getRelationships(parameters)
#
# ARGS
#   parameters      GetRelationships - {http://www.fedora.info/definitions/1/0/types/}getRelationships
#
# RETURNS
#   parameters      GetRelationshipsResponse - {http://www.fedora.info/definitions/1/0/types/}getRelationshipsResponse
#
parameters = nil
puts obj.getRelationships(parameters)

# SYNOPSIS
#   addRelationship(parameters)
#
# ARGS
#   parameters      AddRelationship - {http://www.fedora.info/definitions/1/0/types/}addRelationship
#
# RETURNS
#   parameters      AddRelationshipResponse - {http://www.fedora.info/definitions/1/0/types/}addRelationshipResponse
#
parameters = nil
puts obj.addRelationship(parameters)

# SYNOPSIS
#   purgeRelationship(parameters)
#
# ARGS
#   parameters      PurgeRelationship - {http://www.fedora.info/definitions/1/0/types/}purgeRelationship
#
# RETURNS
#   parameters      PurgeRelationshipResponse - {http://www.fedora.info/definitions/1/0/types/}purgeRelationshipResponse
#
parameters = nil
puts obj.purgeRelationship(parameters)


text:
package com.vinexs.eeb.fragment;

import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import com.vinexs.R;
import com.vinexs.eeb.BaseFragment;

@SuppressWarnings("unused")
public abstract class BaseLayFragment extends BaseFragment {

    int mTheme = R.style.fullScreen_Window;
    boolean mShowsDialog = true;

    Dialog mDialog;
    boolean mViewDestroyed;

    public Dialog getDialog() {
        return mDialog;
    }

    /**
     * @hide
     */
    @Override
    public LayoutInflater getLayoutInflater(Bundle savedInstanceState) {
        if (!mShowsDialog) {
            return super.getLayoutInflater(savedInstanceState);
        }
        mDialog = new Dialog(getActivity(), mTheme);
        if (mDialog != null) {
            return (LayoutInflater) mDialog.getContext().getSystemService(
                    Context.LAYOUT_INFLATER_SERVICE);
        }
        return (LayoutInflater) getActivity().getSystemService(
                Context.LAYOUT_INFLATER_SERVICE);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        if (!mShowsDialog) {
            return;
        }
        View view = getView();
        if (view != null) {
            if (view.getParent() != null) {
                throw new IllegalStateException("DialogFragment can not be attached to a container view. Please use addFragment(0, fragment);");
            }
            mDialog.setContentView(view);
        }
        mDialog.setOwnerActivity(getActivity());
        mDialog.setCancelable(false);
    }

    @Override
    public void onStart() {
        super.onStart();
        if (mDialog != null) {
            mViewDestroyed = false;
            mDialog.show();
            mDialog.getWindow().setLayout(ViewGroup.LayoutParams.MATCH_PARENT,
                    ViewGroup.LayoutParams.MATCH_PARENT);
            mDialog.setOnKeyListener(new DialogInterface.OnKeyListener() {
                @Override
                public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
                    return true;
                }
            });
        }
    }

    @Override
    public void onStop() {
        super.onStop();
        if (mDialog != null) {
            mDialog.hide();
        }
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        if (mDialog != null) {
            // Set removed here because this dismissal is just to hide
            // the dialog -- we don't want this to cause the fragment2 to
            // actually be removed.
            mViewDestroyed = true;
            mDialog.dismiss();
            mDialog = null;
        }
    }

    @Override
    public int getToolbarResId() {
        return 0;
    }

}


text:
<?xml version="1.0"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<parent>
		<groupId>com.lewis.tiger</groupId>
		<artifactId>tiger</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>

	<artifactId>tiger-web-cxf</artifactId>
	<packaging>war</packaging>
	<name>Tiger Web Demo: CXF</name>

	<dependencies>
		<!-- CXF -->
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxws</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-transports-http</artifactId>
		</dependency>
		<!-- Jetty is needed if you're are not using the CXFServlet -->
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-transports-http-jetty</artifactId>
		</dependency>

		<!-- jUnit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
		</dependency>

		<!-- Log4j -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
		</dependency>
	</dependencies>

	<build>
		<finalName>tiger-web-cxf</finalName>
	</build>
</project>


text:
from .mixins import AlexiaForm, AlexiaModelForm, CrispyFormMixin
from .models import EmptyInlineFormSet

__all__ = [
    'AlexiaForm', 'AlexiaModelForm', 'CrispyFormMixin', 'EmptyInlineFormSet'
]


text:
Spree::Core::Engine.routes.draw do
  namespace :admin do
    resources :products do
      resources :sale_prices do
        get :stop
        get :enable
      end
    end
  end
end


text:
vDNA Crosslinks
===============

Security-Database vDNA Crosslinks v2
------------------------------------

vDNA Crosslinks allows you to gather +80.000 security alerts data from [Security-Database](https://www.security-database.com) and export it as JSON. Export provide related alert information. By that we mean, all alerts linked to the first one at specified depth. We limit the depth from 0 (single) to 4, but on demand, we can override this value.

On this exemple, we use D3.js library and Grapher to manipulate and represent links bewteen alerts and severity propagation. Hope you'll like it.

[Security-Database](https://www.security-database.com) provides this information for free for anybody who want to play with, make graphs, stats, publish or anything else. Hope you'll enjoy playing with it and perhaps, let you have some idea ;)

Live Demo
--------

A live demo and self promo web site is actually available here : [http://crosslinks.security-database.com](http://crosslinks.security-database.com). You can play with alerts, data, filters, layout.

The endpoint
------------

The endpoint is hosted by Security-Database. Datas are generated daily, queries and results cached for a maximum performance.

[http://crosslinks.security-database.com/crosslinks.php?alert=[alert]&depth=[depth]](http://crosslinks.security-database.com/crosslinks.php?alert=[alert]&depth=[depth])

This endpoint verify that the Alert name entered is conform (ie : CVE-2012-2010 or MS10-021) and verify that the depth is between 0 and 4 (integer only). Depth 0 will be selected alert only.

Exemples
--------
### Force layout
![Force layout ](/samples/Force.jpg?raw=true)

### Force layout
![Severity layout ](/samples/Severity.jpg?raw=true)

Output Sample
-------------

###Success : Json ouput Exemple
#### Sample :

```json
{
    "success" : true,
    "message" :
        {
        "nodes" : [ {
            "severity" : "Medium",
            "id" : "KB983438",
            "vendor" : "Microsoft",
            "published" : "2010-05-12",
            "type" : "Alerts",
            "links" : 2
        },{(...)}],
        "links" : [ {
            "source" : "MS11-044",
            "target" : "MS12-034"
        },{(...)}]
        }
}
```

#### Definition :
##### Datas (Nodes)
- __severity__ : Source alert severity (Critical, High, Medium, Low or NA)
- __id__ : Alert Name (SD naming scheme)
- __vendor__ : Source vendor (Microsoft, cve, HP...)
- __published__ : Source published date (YYYY-MM-DD)
- __type__ : Actually Alerts, perhaps some other later
- __links__ : Numbers of links from this alert (integer)

##### Datas (Links)
- __source__ : id From
- __target__ : id To

###Error : Json ouput Exemple
#### Sample :
```json
{
	"success" : false,
		"message" : [
	        {
	            "error" : "depth : No specified Depth, must be between 0 and 4"
	        }
	    ]
}
```
#### Definition :
- __Exemple__ : Depth, must be between 0 and 4 (0 is selected alert only)

Updates
---------
- V2.0 Use Grapher to render in WebGL. Faster !! Really faster !!!
- V1.0 Initial release in SVG mode

Credits
---------
- Thanks to Ayasdi for Grapher library that render into WebGL a Canvas! https://github.com/ayasdi/grapher
- Thanks to Jim Vallandingham for his inspiration and demo "How to Make an Interactive Network Visualization" available at http://flowingdata.com/2012/08/02/how-to-make-an-interactive-network-visualization/
- D3js for the awesome works


text:
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64a.c
Label Definition File: CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close.label.xml
Template File: source-sinks-64a.tmpl.c
*/
/*
 * @description
 * CWE: 775 Missing Release of File Descriptor or Handle After Effective Lifetime
 * BadSource:  Open a file using fopen()
 * Sinks:
 *    GoodSink: Close the file using fclose()
 *    BadSink : Do not close file
 * Flow Variant: 64 Data flow: void pointer to data passed from one function to another in different source files
 *
 * */

#include "std_testcase.h"

#ifndef OMITBAD

/* bad function declaration */
void CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64b_badSink(void * dataVoidPtr);

void CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64_bad()
{
    FILE * data;
    data = NULL;
    /* POTENTIAL FLAW: Open a file without closing it */
    data = fopen("BadSource_fopen.txt", "w+");
    CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64b_badSink(&data);
}

#endif /* OMITBAD */

#ifndef OMITGOOD

/* goodB2G uses the BadSource with the GoodSink */
void CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64b_goodB2GSink(void * dataVoidPtr);

static void goodB2G()
{
    FILE * data;
    data = NULL;
    /* POTENTIAL FLAW: Open a file without closing it */
    data = fopen("BadSource_fopen.txt", "w+");
    CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64b_goodB2GSink(&data);
}

void CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64_good()
{
    goodB2G();
}

#endif /* OMITGOOD */

/* Below is the main(). It is only used when building this testcase on
   its own for testing or for building a binary to use in testing binary
   analysis tools. It is not used when compiling all the testcases as one
   application, which is how source code analysis tools are tested. */

#ifdef INCLUDEMAIN

int main(int argc, char * argv[])
{
    /* seed randomness */
    srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
    printLine("Calling good()...");
    CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64_good();
    printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
    printLine("Calling bad()...");
    CWE775_Missing_Release_of_File_Descriptor_or_Handle__fopen_no_close_64_bad();
    printLine("Finished bad()");
#endif /* OMITBAD */
    return 0;
}

#endif