text:
import { join, normalize } from 'path';
import minimist from 'minimist';

const argv = minimist(process.argv.slice(2));

export const env = argv.prod ? 'prod' : 'dev';
export const isDev = argv.dev;
export const isProd = argv.prod;

export const ROOT_DIR = normalize(join(__dirname, '..'));
export const SRC_DIR = join(ROOT_DIR, 'src');
export const DIST_DIR = 'dist';
export const DEST_DIR = join(ROOT_DIR, DIST_DIR, env);

export const html = {
  src: '.',
  dest: '.',
  glob: '**/*.html',
  cacheName: 'html-task'
};

export const assets = {
  src: '.',
  dest: '.',
  glob: '{favicon.ico,robots.txt,sitemap.xml,CNAME}',
  cacheName: 'assets-task'
};

export const js = {
  src: 'js',
  dest: 'js',
  fileName: 'main.js',
  bundleName: 'main.js',
  glob: '**/*.js',
  // noParse is an array which will skip all require() and global parsing for each file in the array. Use this for
  // giant libs like jquery or threejs that don't have any requires or node-style globals but take forever to parse.
  // http://stackoverflow.com/a/18543403/1949274
  noParse: [
    require.resolve('jquery'),
    require.resolve('lodash'),
    require.resolve('bootstrap'),
    require.resolve('tether')
  ],
  // extensions is an array of optional extra extensions for the module lookup machinery to use when the extension
  // has not been specified. By default browserify considers only .js and .json files in such cases.
  extensions: []
};

export const css = {
  src: 'css',
  dest: 'css',
  glob: '**/*.scss',
  cacheName: 'css-task',
  // Autoprefixer uses Browserslist, so you can specify the browsers you want to target in your project by queries
  // like last 2 versions or > 5%. For more info check out https://github.com/ai/browserslist#browsers and
  // https://github.com/ai/browserslist#queries
  autoprefixerBrowsers: [
    'ie >= 10',
    'ie_mob >= 10',
    'ff >= 30',
    'chrome >= 34',
    'safari >= 7',
    'opera >= 23',
    'ios >= 7',
    'android >= 4.4',
    'bb >= 10'
  ],
  postCSSAssetsLoadPaths: [
    join(DEST_DIR, 'images'),
    join(DEST_DIR, 'fonts')
  ]
};

export const images = {
  src: '.',
  dest: 'images',
  glob: '**/*.+(png|jpg|jpeg|gif|bmp|svg)',
  cacheName: 'images-task'
};

export const fonts = {
  src: '.',
  dest: 'fonts',
  glob: '**/*.+(eot|ttf|woff|woff2|otf)',
  cacheName: 'fonts-task'
};

export const jsLint = {
  src: '.',
  glob: '**/*.js',
  ignoreGlob: '!**/node_modules/**',
  // Same as `cssLint.ideSupport`. For this you need `eslint` support.
  ideSupport: true,
  cacheName: 'js-lint-task'
};

export const rev = {
  manifestFile: 'rev-manifest.json',
  assets: {
    glob: '**/*',
    ignoreGlob: '**/*.+(html|map)'
  },
  updateReferences: {
    glob: '**/*.+(html|css|js)'
  }
};

export const sizeReport = {
  src: '.',
  glob: '**/*',
  ignoreGlob: '!**/rev-manifest.json'
};

export const watch = {
  // javascript wathing handled in the javascripts task
  watchableTasks: ['html', 'assets', 'fonts', 'images', 'css']
};

export const browserSync = {
  port: argv.port || (isProd ? 8080 : 3000)
};

export const checkVersions = {
  npm: '2.14.2',
  node: '4.0.0'
};

export const prodTasks = [
  'clean',
  [
    'js-lint'
  ],
  'images',
  [
    'html',
    'fonts',
    'css',
    'js'
  ],
  'rev-assets',
  'rev-update-references',
  'assets',
  'size-report'
];

export const devTasks = [
  'clean',
  'images',
  [
    'html',
    'assets',
    'fonts',
    'css',
    'js'
  ],
  'watch'
];


text:
// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.

#pragma once

#include "Border.generated.h"

class USlateBrushAsset;

/**
 * A border is a container widget that can contain one child widget, providing an opportunity
 * to surround it with a background image and adjustable padding.
 *
 * ● Single Child
 * ● Image
 */
UCLASS()
class UMG_API UBorder : public UContentWidget
{
	GENERATED_UCLASS_BODY()

public:

	/** Color and opacity multiplier of content in the border */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Content", meta=( sRGB="true" ))
	FLinearColor ContentColorAndOpacity;

	/** A bindable delegate for the ContentColorAndOpacity. */
	UPROPERTY()
	FGetLinearColor ContentColorAndOpacityDelegate;

	/** The padding area between the slot and the content it contains. */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Content")
	FMargin Padding;

	/** The alignment of the content horizontally. */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Content")
	TEnumAsByte<EHorizontalAlignment> HorizontalAlignment;

	/** The alignment of the content vertically. */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Content")
	TEnumAsByte<EVerticalAlignment> VerticalAlignment;

	/** Brush to drag as the background */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Appearance, meta=( DisplayName="Brush" ))
	FSlateBrush Background;

	/** A bindable delegate for the Brush. */
	UPROPERTY()
	FGetSlateBrush BackgroundDelegate;

	/** Color and opacity of the actual border image */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Appearance, meta=( sRGB="true" ))
	FLinearColor BrushColor;

	/** A bindable delegate for the BrushColor. */
	UPROPERTY()
	FGetLinearColor BrushColorDelegate;

	/** Whether or not to show the disabled effect when this border is disabled */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Appearance, AdvancedDisplay)
	bool bShowEffectWhenDisabled;

public:

	UPROPERTY(EditAnywhere, Category=Events, meta=( IsBindableEvent="True" ))
	FOnPointerEvent OnMouseButtonDownEvent;

	UPROPERTY(EditAnywhere, Category=Events, meta=( IsBindableEvent="True" ))
	FOnPointerEvent OnMouseButtonUpEvent;

	UPROPERTY(EditAnywhere, Category=Events, meta=( IsBindableEvent="True" ))
	FOnPointerEvent OnMouseMoveEvent;

	UPROPERTY(EditAnywhere, Category=Events, meta=( IsBindableEvent="True" ))
	FOnPointerEvent OnMouseDoubleClickEvent;

public:

	/**  */
	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetContentColorAndOpacity(FLinearColor InContentColorAndOpacity);

	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetPadding(FMargin InPadding);

	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetHorizontalAlignment(EHorizontalAlignment InHorizontalAlignment);

	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetVerticalAlignment(EVerticalAlignment InVerticalAlignment);

	/**  */
	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetBrushColor(FLinearColor InBrushColor);

	/**  */
	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetBrush(const FSlateBrush& InBrush);

	/**  */
	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetBrushFromAsset(USlateBrushAsset* Asset);

	/**  */
	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetBrushFromTexture(UTexture2D* Texture);

	/**  */
	UFUNCTION(BlueprintCallable, Category="Appearance")
	void SetBrushFromMaterial(UMaterialInterface* Material);

	/**  */
	UFUNCTION(BlueprintCallable, Category="Appearance")
	UMaterialInstanceDynamic* GetDynamicMaterial();

public:

	// UWidget interface
	virtual void SynchronizeProperties() override;
	// End of UWidget interface

	// UVisual interface
	virtual void ReleaseSlateResources(bool bReleaseChildren) override;
	// End of UVisual interface

	// Begin UObject interface
	virtual void PostLoad() override;
	// End of UObject interface

#if WITH_EDITOR
	// UObject interface
	virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
	// End of UObject interface

	virtual const FSlateBrush* GetEditorIcon() override;
	virtual const FText GetPaletteCategory() override;
#endif

protected:

	// UPanelWidget
	virtual UClass* GetSlotClass() const override;
	virtual void OnSlotAdded(UPanelSlot* Slot) override;
	virtual void OnSlotRemoved(UPanelSlot* Slot) override;
	// End UPanelWidget

protected:
	TSharedPtr<SBorder> MyBorder;

protected:
	// UWidget interface
	virtual TSharedRef<SWidget> RebuildWidget() override;
	// End of UWidget interface

	FReply HandleMouseButtonDown(const FGeometry& Geometry, const FPointerEvent& MouseEvent);
	FReply HandleMouseButtonUp(const FGeometry& Geometry, const FPointerEvent& MouseEvent);
	FReply HandleMouseMove(const FGeometry& Geometry, const FPointerEvent& MouseEvent);
	FReply HandleMouseDoubleClick(const FGeometry& Geometry, const FPointerEvent& MouseEvent);

	/** Translates the bound brush data and assigns it to the cached brush used by this widget. */
	const FSlateBrush* ConvertImage(TAttribute<FSlateBrush> InImageAsset) const;

protected:
	/** Image to use for the border */
	UPROPERTY()
	USlateBrushAsset* Brush_DEPRECATED;
};

redpajama_set_name: RedPajamaGithub


text:
namespace bsoncxx {
BSONCXX_INLINE_NAMESPACE_BEGIN

///
/// An enumeration of each BSON type.
/// These x-macros will expand to be of the form:
///    k_double = 0x01,
///    k_utf8 = 0x02,
///    k_document = 0x03,
///    k_array = 0x04 ...
///
enum class type : std::uint8_t {
#define BSONCXX_ENUM(name, val) k_##name = val,
#include <bsoncxx/enums/type.hpp>
#undef BSONCXX_ENUM
};

///
/// An enumeration of each BSON binary sub type.
/// These x-macros will expand to be of the form:
///   k_binary = 0x00,
///   k_function = 0x01,
///   k_binary_deprecated = 0x02,
///   k_uuid_deprecated = 0x03,
///   k_uuid = 0x04 ...
///
enum class binary_sub_type : std::uint8_t {
#define BSONCXX_ENUM(name, val) k_##name = val,
#include <bsoncxx/enums/binary_sub_type.hpp>
#undef BSONCXX_ENUM
};

///
/// Returns a stringification of the given type.
///
/// @param rhs
///   The type to stringify.
///
/// @return a std::string representation of the type.
///
BSONCXX_API std::string BSONCXX_CALL to_string(type rhs);

///
/// Returns a stringification of the given binary sub type.
///
/// @param rhs
///   The type to stringify.
///
/// @return a std::string representation of the type.
///
BSONCXX_API std::string BSONCXX_CALL to_string(binary_sub_type rhs);

namespace types {

///
/// A BSON double value.
///
struct BSONCXX_API b_double {
    static constexpr auto type_id = type::k_double;

    double value;

    ///
    /// Conversion operator unwrapping a double
    ///
    BSONCXX_INLINE operator double() {
        return value;
    }
};

///
/// free function comparator for b_double
///
/// @relatesalso b_double
///
BSONCXX_INLINE bool operator==(const b_double& lhs, const b_double& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON UTF-8 encoded string value.
///
struct BSONCXX_API b_utf8 {
    static constexpr auto type_id = type::k_utf8;

    ///
    /// Constructor for b_utf8.
    ///
    /// @param value
    ///   The value to wrap.
    ///
    template <typename T>
    BSONCXX_INLINE explicit b_utf8(T&& value)
        : value(std::forward<T>(value)) {
    }

    stdx::string_view value;

    ///
    /// Conversion operator unwrapping a string_view
    ///
    BSONCXX_INLINE operator stdx::string_view() {
        return value;
    }
};

///
/// free function comparator for b_utf8
///
/// @relatesalso b_utf8
///
BSONCXX_INLINE bool operator==(const b_utf8& lhs, const b_utf8& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON document value.
///
struct BSONCXX_API b_document {
    static constexpr auto type_id = type::k_document;

    document::view value;

    ///
    /// Conversion operator unwrapping a document::view
    ///
    BSONCXX_INLINE operator document::view() {
        return value;
    }

    ///
    /// Returns an unwrapped document::view
    ///
    BSONCXX_INLINE document::view view() {
        return value;
    }
};

///
/// free function comparator for b_document
///
/// @relatesalso b_document
///
BSONCXX_INLINE bool operator==(const b_document& lhs, const b_document& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON array value.
///
struct BSONCXX_API b_array {
    static constexpr auto type_id = type::k_array;

    array::view value;

    ///
    /// Conversion operator unwrapping an array::view
    ///
    BSONCXX_INLINE operator array::view() {
        return value;
    }
};

///
/// free function comparator for b_array
///
/// @relatesalso b_array
///
BSONCXX_INLINE bool operator==(const b_array& lhs, const b_array& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON binary data value.
///
struct BSONCXX_API b_binary {
    static constexpr auto type_id = type::k_binary;

    binary_sub_type sub_type;
    uint32_t size;
    const uint8_t* bytes;
};

///
/// free function comparator for b_binary
///
/// @relatesalso b_binary
///
BSONCXX_INLINE bool operator==(const b_binary& lhs, const b_binary& rhs) {
    return lhs.sub_type == rhs.sub_type && lhs.size == rhs.size &&
           (std::memcmp(lhs.bytes, rhs.bytes, lhs.size) == 0);
}

///
/// A BSON undefined value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_undefined {
    static constexpr auto type_id = type::k_undefined;
};

///
/// free function comparator for b_undefined
///
/// @relatesalso b_undefined
///
BSONCXX_INLINE bool operator==(const b_undefined&, const b_undefined&) {
    return true;
}

///
/// A BSON ObjectId value.
///
struct BSONCXX_API b_oid {
    static constexpr auto type_id = type::k_oid;

    oid value;
};

///
/// free function comparator for b_oid
///
/// @relatesalso b_oid
///
BSONCXX_INLINE bool operator==(const b_oid& lhs, const b_oid& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON boolean value.
///
struct BSONCXX_API b_bool {
    static constexpr auto type_id = type::k_bool;

    bool value;

    ///
    /// Conversion operator unwrapping a bool
    ///
    BSONCXX_INLINE operator bool() {
        return value;
    }
};

///
/// free function comparator for b_bool
///
/// @relatesalso b_bool
///
BSONCXX_INLINE bool operator==(const b_bool& lhs, const b_bool& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON date value.
///
struct BSONCXX_API b_date {
    static constexpr auto type_id = type::k_date;

    ///
    /// Constructor for b_date
    ///
    /// @param value
    ///   An int64_t representing milliseconds since the epoch.
    ///
    BSONCXX_INLINE
    explicit b_date(int64_t value) : value(value) {
    }

    ///
    /// Constructor for b_date
    ///
    /// @param value
    ///   A system_clock time_point.
    ///
    BSONCXX_INLINE
    explicit b_date(const std::chrono::system_clock::time_point& tp)
        : value(std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch())
                    .count()) {
    }

    int64_t value;

    ///
    /// Conversion operator unwrapping a int64_t
    ///
    BSONCXX_INLINE operator int64_t() {
        return value;
    }

    ///
    /// Conversion operator unwrapping a time_point
    ///
    BSONCXX_INLINE operator std::chrono::system_clock::time_point() {
        return std::chrono::system_clock::time_point(
            std::chrono::duration_cast<std::chrono::system_clock::duration>(
                std::chrono::milliseconds{value}));
    }
};

///
/// free function comparator for b_date
///
/// @relatesalso b_date
///
BSONCXX_INLINE bool operator==(const b_date& lhs, const b_date& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON null value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_null {
    static constexpr auto type_id = type::k_null;
};

///
/// free function comparator for b_null
///
/// @relatesalso b_null
///
BSONCXX_INLINE bool operator==(const b_null&, const b_null&) {
    return true;
}

///
/// A BSON regex value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_regex {
    static constexpr auto type_id = type::k_regex;

    ///
    /// Constructor for b_regex
    ///
    /// @param regex
    ///   The regex pattern
    ///
    /// @param options
    ///   The regex options
    ///
    template <typename T, typename U>
    BSONCXX_INLINE explicit b_regex(T&& regex, U&& options)
        : regex(std::forward<T>(regex)), options(std::forward<U>(options)) {
    }

    stdx::string_view regex;
    stdx::string_view options;
};

///
/// free function comparator for b_regex
///
/// @relatesalso b_regex
///
BSONCXX_INLINE bool operator==(const b_regex& lhs, const b_regex& rhs) {
    return lhs.regex == rhs.regex && lhs.options == rhs.options;
}

///
/// A BSON DBPointer value.
///
/// @deprecated
///   A BSON DBPointer (aka DBRef) is still supported but deprecated.
///
struct BSONCXX_API b_dbpointer {
    static constexpr auto type_id = type::k_dbpointer;

    stdx::string_view collection;
    oid value;
};

///
/// free function comparator for b_dbpointer
///
/// @relatesalso b_dbpointer
///
BSONCXX_INLINE bool operator==(const b_dbpointer& lhs, const b_dbpointer& rhs) {
    return lhs.collection == rhs.collection && lhs.value == rhs.value;
}

///
/// A BSON JavaScript code value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_code {
    static constexpr auto type_id = type::k_code;

    ///
    /// Constructor for b_code.
    ///
    /// @param code
    ///   The js code
    ///
    template <typename T>
    BSONCXX_INLINE explicit b_code(T&& code)
        : code(std::forward<T>(code)) {
    }

    stdx::string_view code;

    ///
    /// Conversion operator unwrapping a string_view
    ///
    BSONCXX_INLINE operator stdx::string_view() {
        return code;
    }
};

///
/// free function comparator for b_code
///
/// @relatesalso b_code
///
BSONCXX_INLINE bool operator==(const b_code& lhs, const b_code& rhs) {
    return lhs.code == rhs.code;
}

///
/// A BSON JavaScript code value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_symbol {
    static constexpr auto type_id = type::k_symbol;

    ///
    /// Constructor for b_symbol.
    ///
    /// @param symbol
    ///   The symbol.
    ///
    template <typename T>
    BSONCXX_INLINE explicit b_symbol(T&& symbol)
        : symbol(std::forward<T>(symbol)) {
    }

    stdx::string_view symbol;

    ///
    /// Conversion operator unwrapping a string_view
    ///
    BSONCXX_INLINE operator stdx::string_view() {
        return symbol;
    }
};

///
/// free function comparator for b_symbol
///
/// @relatesalso b_symbol
///
BSONCXX_INLINE bool operator==(const b_symbol& lhs, const b_symbol& rhs) {
    return lhs.symbol == rhs.symbol;
}

///
/// A BSON JavaScript code with scope value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_codewscope {
    static constexpr auto type_id = type::k_codewscope;

    ///
    /// Constructor for b_codewscope.
    ///
    /// @param code
    ///   The js code
    ///
    /// @param scope
    ///   A bson document view holding the scope environment.
    ///
    template <typename T, typename U>
    BSONCXX_INLINE explicit b_codewscope(T&& code, U&& scope)
        : code(std::forward<T>(code)), scope(std::forward<U>(scope)) {
    }

    stdx::string_view code;
    document::view scope;
};

///
/// free function comparator for b_codewscope
///
/// @relatesalso b_codewscope
///
BSONCXX_INLINE bool operator==(const b_codewscope& lhs, const b_codewscope& rhs) {
    return lhs.code == rhs.code && lhs.scope == rhs.scope;
}

///
/// A BSON signed 32-bit integer value.
///
struct BSONCXX_API b_int32 {
    static constexpr auto type_id = type::k_int32;

    int32_t value;

    ///
    /// Conversion operator unwrapping a int32_t
    ///
    BSONCXX_INLINE operator int32_t() {
        return value;
    }
};

///
/// free function comparator for b_int32
///
/// @relatesalso b_int32
///
BSONCXX_INLINE bool operator==(const b_int32& lhs, const b_int32& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON replication timestamp value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_timestamp {
    static constexpr auto type_id = type::k_timestamp;

    uint32_t increment;
    uint32_t timestamp;
};

///
/// free function comparator for b_timestamp
///
/// @relatesalso b_timestamp
///
BSONCXX_INLINE bool operator==(const b_timestamp& lhs, const b_timestamp& rhs) {
    return lhs.increment == rhs.increment && lhs.timestamp == rhs.timestamp;
}

///
/// A BSON 64-bit signed integer value.
///
struct BSONCXX_API b_int64 {
    static constexpr auto type_id = type::k_int64;

    int64_t value;

    ///
    /// Conversion operator unwrapping a int64_t
    ///
    BSONCXX_INLINE operator int64_t() {
        return value;
    }
};

///
/// free function comparator for b_int64
///
/// @relatesalso b_int64
///
BSONCXX_INLINE bool operator==(const b_int64& lhs, const b_int64& rhs) {
    return lhs.value == rhs.value;
}

///
/// A BSON min-key value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_minkey {
    static constexpr auto type_id = type::k_minkey;
};

///
/// free function comparator for b_minkey
///
/// @relatesalso b_minkey
///
BSONCXX_INLINE bool operator==(const b_minkey&, const b_minkey&) {
    return true;
}

///
/// A BSON max-key value.
///
/// @warning
///   This BSON type is used internally by the MongoDB server - use by clients
///   is discouraged.
///
struct BSONCXX_API b_maxkey {
    static constexpr auto type_id = type::k_maxkey;
};

///
/// free function comparator for b_maxkey
///
/// @relatesalso b_maxkey
///
BSONCXX_INLINE bool operator==(const b_maxkey&, const b_maxkey&) {
    return true;
}

#define BSONCXX_ENUM(name, val)                                                \
    BSONCXX_INLINE bool operator!=(const b_##name& lhs, const b_##name& rhs) { \
        return !(lhs == rhs);                                                  \
    }
#include <bsoncxx/enums/type.hpp>
#undef BSONCXX_ENUM

}  // namespace types
BSONCXX_INLINE_NAMESPACE_END
}  // namespace bsoncxx

#include <bsoncxx/config/postlude.hpp>


text:
package org.orienteer.standalone;

import java.net.URL;
import java.security.ProtectionDomain;

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.bio.SocketConnector;
import org.eclipse.jetty.util.resource.Resource;
import org.eclipse.jetty.webapp.WebAppContext;

/**
 * Utility class to run jetty server according to specified parameters
 */
public class ServerRunner
{
	public static final int DEFAULT_TIMEOUT = 60*60*1000;
	public static final int DEFAULT_PORT = 8080;

	private String host = null;
	private int port = DEFAULT_PORT;
	private int timeout = DEFAULT_TIMEOUT;

	private Server server;

	public ServerRunner()
	{
	}

	public ServerRunner(String host, int port)
	{
		this.host = host;
		this.port = port;
	}

	public ServerRunner(String host, int port, int timeout)
	{
		this.host = host;
		this.port = port;
		this.timeout = timeout;
	}

	public void start() throws Exception
	{
		if(server==null)
		{
	        server = new Server();
	        SocketConnector connector = new SocketConnector();

	        // Set some timeout options to make debugging easier.
	        connector.setMaxIdleTime(timeout);
	        connector.setSoLingerTime(-1);
	        if(host!=null) connector.setHost(host);
	        connector.setPort(port);
	        server.addConnector(connector);
	        Resource.setDefaultUseCaches(false);

	        WebAppContext bb = new WebAppContext();
	        bb.setServer(server);
	        bb.setContextPath("/");
	        ProtectionDomain protectionDomain = ServerRunner.class.getProtectionDomain();
	        URL location = protectionDomain.getCodeSource().getLocation();
	        System.out.println("loading from "+location);
	        bb.setWar(location.toExternalForm());
	        bb.setExtractWAR(false);
	        bb.setCopyWebInf(true);
	        bb.setCopyWebDir(false);

	        // START JMX SERVER
	        // MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
	        // MBeanContainer mBeanContainer = new MBeanContainer(mBeanServer);
	        // server.getContainer().addEventListener(mBeanContainer);
	        // mBeanContainer.start();

	        server.setHandler(bb);
            server.start();
		}
	}

	public void stop() throws Exception
	{
		if(server!=null)server.stop();
	}

	public void join() throws Exception
	{
		if(server!=null) server.join();
	}
}


text:
module Sasspectations
  VERSION = "0.0.3"
end


text:
<?php

namespace Doctrine\Tests\DBAL\Types;

use Doctrine\Tests\DBAL\Mocks\MockPlatform;
use PHPUnit_Framework_TestCase;

abstract class BaseDateTypeTestCase extends PHPUnit_Framework_TestCase
{
    /**
     * @var MockPlatform
     */
    protected $platform;

    /**
     * @var \Doctrine\DBAL\Types\Type
     */
    protected $type;

    /**
     * @var string
     */
    private $currentTimezone;

    /**
     * {@inheritDoc}
     */
    protected function setUp()
    {
        $this->platform        = new MockPlatform();
        $this->currentTimezone = date_default_timezone_get();

        $this->assertInstanceOf('Doctrine\DBAL\Types\Type', $this->type);
    }

    /**
     * {@inheritDoc}
     */
    protected function tearDown()
    {
        date_default_timezone_set($this->currentTimezone);
    }

    public function testDateConvertsToDatabaseValue()
    {
        $this->assertInternalType('string', $this->type->convertToDatabaseValue(new \DateTime(), $this->platform));
    }

    /**
     * @dataProvider invalidPHPValuesProvider
     *
     * @param mixed $value
     */
    public function testInvalidTypeConversionToDatabaseValue($value)
    {
        $this->setExpectedException('Doctrine\DBAL\Types\ConversionException');

        $this->type->convertToDatabaseValue($value, $this->platform);
    }

    public function testNullConversion()
    {
        $this->assertNull($this->type->convertToPHPValue(null, $this->platform));
    }

    public function testConvertDateTimeToPHPValue()
    {
        $date = new \DateTime('now');

        $this->assertSame($date, $this->type->convertToPHPValue($date, $this->platform));
    }

    /**
     * @group #2794
     *
     * Note that while \@see \DateTimeImmutable is supposed to be handled
     * by @see \Doctrine\DBAL\Types\DateTimeImmutableType, previous DBAL versions handled it just fine.
     * This test is just in place to prevent further regressions, even if the type is being misused
     */
    public function testConvertDateTimeImmutableToPHPValue()
    {
        $date = new \DateTimeImmutable('now');

        self::assertSame($date, $this->type->convertToPHPValue($date, $this->platform));
    }

    /**
     * @group #2794
     *
     * Note that while \@see \DateTimeImmutable is supposed to be handled
     * by @see \Doctrine\DBAL\Types\DateTimeImmutableType, previous DBAL versions handled it just fine.
     * This test is just in place to prevent further regressions, even if the type is being misused
     */
    public function testDateTimeImmutableConvertsToDatabaseValue()
    {
        self::assertInternalType(
            'string',
            $this->type->convertToDatabaseValue(new \DateTimeImmutable(), $this->platform)
        );
    }

    /**
     * @return mixed[][]
     */
    public function invalidPHPValuesProvider()
    {
        return [
            [0],
            [''],
            ['foo'],
            ['10:11:12'],
            ['2015-01-31'],
            ['2015-01-31 10:11:12'],
            [new \stdClass()],
            [$this],
            [27],
            [-1],
            [1.2],
            [[]],
            [['an array']],
        ];
    }
}


text:
require 'test_helper'

class TecnologiaBbcTest < ActiveSupport::TestCase
  # test "the truth" do
  #   assert true
  # end
end


text:
.mblToolBarButtonHasArrow-styles {
  width: 27px;
  height: 27px;
  border-radius: 20px;
  border: 2px solid #ffffff;
  padding: 0px;
  margin: 0px;
  margin-top: 8px;
  margin-bottom: 8px;
  background-image: url("images/dark/back.png");
  background-position: 50% 50%;
  background-size: 27px 27px;
  background-repeat: no-repeat;
}
/* dojox.mobile.RoundRect */
.mblRoundRect {
  margin: 7px 9px 16px;
  padding: 8px;
  border: 1px solid #cccccc;
  border-radius: 8px;
  background-color: #ffffff;
  border: none;
  background-color: transparent;
  border-radius: 0px;
  margin: 0px;
  padding: 0px;
}
.mblRoundRect.mblShadow {
  -webkit-box-shadow: none;
  box-shadow: none;
}


text:
enum LogLevel {
  DEBUG = 0, INFO = 1, WARNING = 2, ERROR = 3, FATAL = 4
};

class Log {
 public:
  Log(LogLevel level);
  virtual ~Log();

  template<class T>
  Log& operator<<(T data) {
    log_msg_stream_ << data;
    return *this;
  }

  // TODO(odain) We could override this to be able to set different handlers for
  // each level.
  static void SetOutputHandler(OutputHandler* handler) {
    output_handler_ = handler;
  }
  static void SetOutputStream(std::ostream* stream) {
    SetOutputHandler(OutputHandler::GetHandler(stream));
  }
  static LogLevel ApplicationLogLevel() {
    return application_log_level_;
  }

  static void SetApplicationLogLevel(LogLevel level) {
    application_log_level_ = level;
  }
 private:
  std::string LogLevelString(LogLevel level) const;
  LogLevel log_level_;

  std::stringstream log_msg_stream_;
  static OutputHandler* output_handler_;
  static LogLevel application_log_level_;
};

// Two if statements here. The 1st checks against MIN_LOG_LEVEL since that's
// known at compile time. Thus if level is < MIN_LOG_LEVEL the compiler will
// completely remove the statement from the binary. The second if compares to
// the CurrentLevel(), which can be set via command line flags and such. If this
// if is false none of the operator<< statements execute. Only if both "if"
// statements evaluate to false does a Log object get constructed and the
// operator<< functions get called.
#define LOG(level) if (level < MIN_LOG_LEVEL) ; \
    else if (level < Log::ApplicationLogLevel()) ; \
    else Log(level)

#endif  // header guard


text:
package org.unidal.cat.core.document.spi;

import java.util.ArrayList;
import java.util.List;

public enum Document {
	INDEX("index", "Index", "glyphicon glyphicon-home", false) {
		{
			defineFeature("overview", "Overview");
			defineFeature("customer", "Customer");
		}
	},

	RELEASE("release", "Release", "glyphicon glyphicon-book", false) {
		{
			defineFeature("release", "Release");
		}
	},

	DEPLOY("deployment", "Deployment", "fa fa-cogs", false) {
		{
			defineFeature("production", "Production");
		}
	},

	USER("user", "User Guide", "fa fa-users", true) {
		{
			defineFeature("overall", "Overall");
			defineFeature("logview", "Logview");
		}
	},

	CLIENT("client", "Client Side", "fa fa-globe", true) {
		{
			defineFeature("app", "Mobile App");
			defineFeature("web", "Web App");
		}
	},

	ALERT("alert", "Alerting", "fa fa-bell", true) {
		{
			defineFeature("overall", "Overall");
		}
	},

	INSTRUMENT("instrument", "Instrument", "fa fa-cutlery", false) {
		{
			defineFeature("instrument", "Instrument");
		}
	},

	API("api", "API Reference", "glyphicon glyphicon-align-left", true) {
		{

		}
	},

	DEVELOPER("developer", "Developer", "glyphicon glyphicon-refresh", false) {
		{
			defineFeature("developer", "Developer");
		}
	},

	ARCHITECTURE("architecture", "Architecture", "fa fa-book", false) {
		{
			defineFeature("architecture", "Architecture");
		}
	},

	FAQ("faq", "FAQ", "fa fa-inbox", false) {
		{
			defineFeature("faq", "FAQ");
		}
	},

	PLUGIN("plugin", "Plugin", "fa fa-key", false) {
		{
			defineFeature("plugin", "Plugin");
		}
	};

	private String m_id;

	private String m_title;

	private String m_styleClasses;

	private List<DocumentFeature> m_features = new ArrayList<DocumentFeature>();

	private boolean m_tabbed;

	private Document(String id, String title, String styleClasses, boolean tabbed) {
		m_id = id;
		m_title = title;
		m_styleClasses = styleClasses;
		m_tabbed = tabbed;
	}

	public static Document getById(String id, Document defaultValue) {
		for (Document doc : values()) {
			if (doc.getId().equals(id)) {
				return doc;
			}
		}

		return defaultValue;
	}

	protected void defineFeature(String id, String title) {
		String url = String.format("/jsp/document/%s/%s.jsp", m_id, id);

		m_features.add(new DocumentFeature(id, title, url));
	}

	public List<DocumentFeature> getFeatures() {
		return m_features;
	}

	public String getId() {
		return m_id;
	}

	public String getStyleClasses() {
		return m_styleClasses;
	}

	public String getTitle() {
		return m_title;
	}

	public boolean isTabbed() {
		return m_tabbed;
	}

	public void register(String id, String title) {
		String url = String.format("/jsp/document/%s/%s.jsp", m_id, id);

		register(id, title, url);
	}

	public void register(String id, String title, String url) {
		DocumentFeature feature = new DocumentFeature(id, title, url);

		if (!m_features.contains(feature)) {
			m_features.add(feature);
		}

		sortFeatures();
	}

	private void sortFeatures() {
		// TODO
	}
}


text:
/** @module misc */ /** */
export * from "./devicePixelRatio";
export * from "./IsMobile";


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta name="twitter:site" content="@kivyframework">

    <title>Spelling — Kivy 1.10.0 ドキュメント</title>
    <link href='//fonts.googleapis.com/css?family=Source+Code+Pro:400,700' rel='stylesheet' type='text/css'>
    <link rel="stylesheet" href="_static/fresh.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />

    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" />
    <link rel="top" title="Kivy 1.10.0 ドキュメント" href="index.html" />
    <link rel="up" title="Core Abstraction(翻訳済み)" href="api-kivy.core.html" />
    <link rel="next" title="Text" href="api-kivy.core.text.html" />
    <link rel="prev" title="Image" href="api-kivy.core.image.html" />

Guides

Garden

API Reference

PDF

Wiki

Quick search

            <form class="search" action="search.html" method="get">

                <input type="hidden" name="check_keywords" value="yes" />
                <input type="hidden" name="area" value="default" />
                <input type="text" class="text" name="q" />
            </form>

Getting Started(翻訳済み)

Introduction (翻訳済み)

Installation(翻訳済み)

A first App(翻訳済み)

Properties(翻訳済み)

Kv Design Language(翻訳済み)

Events(翻訳済み)

Non-widget stuff(翻訳済み)

Layouts(翻訳済み)

Drawing(翻訳済み)

Packaging(翻訳済み)

Examples(翻訳済み)

Diving in(翻訳済み)

Gallery of Examples(翻訳済み)

Gallery(翻訳済み)

3D Rotating Monkey Head(翻訳済み)

Widget animation(翻訳済み)

Suite of Application Builders(翻訳済み)

Application example using build() + return(翻訳済み)

Application built from a  .kv fil(翻訳済み)

Application from a .kv in a Template Directory(翻訳済み)

Camera Example(翻訳済み)

Bezier Example(翻訳済み)

Canvas stress(翻訳済み)

Circle Example(翻訳済み)

FBO Canvas(翻訳済み)

Line (SmoothLine) Experiment(翻訳済み)

Lines Extended Demo(翻訳済み)

Mesh test(翻訳済み)

Multitexture Example(翻訳済み)

Repeat Texture on Resize(翻訳済み)

Rotation Example(翻訳済み)

Stencil demo(翻訳済み)

Tesselate Demonstration

Texture Wrapping and Coordinates Example(翻訳済み)

Shuffled Camera Feed Puzzle(翻訳済み)

Kivy Catalog(翻訳済み)

Multistroke Recognition Database Demonstration(翻訳済み)

Basic Picture Viewer(翻訳済み)

Live Shader Editor(翻訳済み)

Showcase of Kivy Features

Touch Tracer Line Drawing Demonstration(翻訳済み)

User's Guide(翻訳済み)

Installation(翻訳済み)

Philosophy(翻訳済み)

Contributing(翻訳済み)

FAQ (翻訳済み)

Contact Us(翻訳済み)

Programming Guide(翻訳済み)

Kivy Basics(翻訳済み)

Controlling the environment(翻訳済み)

Configure Kivy(翻訳済み)

Architectural Overview(翻訳済み)

Events and Properties (翻訳済み)

Input management (翻訳済み)

Widgets(翻訳済み)

Graphics (翻訳済み)

Kv language(翻訳済み)

Integrating with other Frameworks(翻訳済み)

Packaging your application(翻訳済み)

Package licensing (翻訳済み)

Tutorials(翻訳済み)

Pong Game Tutorial(翻訳済み)

A Simple Paint App(翻訳済み)

Crash Course(翻訳済み)

API Reference

Kivy framework(翻訳済み)

Adapters

Adapter

List Item View Argument Converters

DictAdapter

ListAdapter

SelectableDataItem

SimpleListAdapter

Animation(翻訳済み)

Application (翻訳中)

Atlas

Kivy Base

Cache manager

Clock object(翻訳ずみ)

Compatibility module for Python 2.7 and > 3.3

Configuration object

Context

Core Abstraction(翻訳済み)

Audio

Camera

Clipboard(翻訳済み)

OpenGL

Image

Spelling

Text

Text Markup

Text layout

Video

Window

Kivy module for binary dependencies.

Effects

Damped scroll effect

Kinetic effect

Opacity scroll effect

Scroll effect

Event dispatcher

Factory object

Garden

Geometry utilities

Gesture recognition

Graphics(翻訳中)

CGL: standard C interface for OpenGL

Graphics compiler

Context management

Context instructions

Framebuffer

GL instructions

Canvas

OpenGL

OpenGL utilities

Scissor Instructions

Shader

Stencil instructions

SVG

Tesselator

Texture

Transformation

Input management

Motion Event Factory

Motion Event

Input Postprocessing

Calibration

Dejitter

Double Tap

Ignore list

Retain Touch

Triple Tap

Motion Event Provider

Providers

Android Joystick Input Provider

Native support for HID input from the linux kernel

Leap Motion - finger only

Native support of Wacom tablet from linuxwacom driver

Native support of MultitouchSupport framework for MacBook (MaxOSX platform)

Mouse provider implementation

Native support for Multitouch devices on Linux, using libmtdev.

Auto Create Input Provider Config Entry for Available MT Hardware (linux only).

TUIO Input Provider

Common definitions for a Windows provider

Support for WM_PEN messages (Windows platform)

Support for WM_TOUCH messages (Windows platform)

Input recorder

Motion Event Shape

Interactive launcher

Kivy Language(翻訳済み)

Builder

Parser

External libraries

DDS File library

GstPlayer

Python mtdev

OSC

NO DOCUMENTATION (module kivy.uix.recycleview)

simpleOSC 0.2

Asynchronous data loader

Logger object

Metrics

Modules

Console

Inspector

JoyCursor

Keybinding

Monitor module

Recorder module

Screen

Touchring

Web Debugger

Multistroke gesture recognizer

Network support

UrlRequest

Parser utilities

Properties

Resources management

Storage

Dictionary store

JSON store

Redis Store

Support

Tools

Packaging

Pyinstaller hooks

Widgets(翻訳済み)

Abstract View

Accordion

Action Bar

Anchor Layout

Behaviors

Button Behavior

Code Navigation Behavior

Compound Selection Behavior

Cover Behavior

Drag Behavior

Emacs Behavior

Focus Behavior

Kivy Namespaces

ToggleButton Behavior

Box Layout

Bubble

Button

Camera

Carousel

CheckBox

Code Input

Color Picker

Drop-Down List

EffectWidget

FileChooser

Float Layout

Gesture Surface

Grid Layout

Image

Label(翻訳済み)

Layout

List View

ModalView

PageLayout

Popup

Progress Bar

RecycleBoxLayout

RecycleGridLayout

RecycleLayout

RecycleView

RecycleView Data Model

RecycleView Layouts

RecycleView Views

Relative Layout

reStructuredText renderer

Sandbox

Scatter

Scatter Layout

Screen Manager

ScrollView

SelectableView

Settings (翻訳中)

Slider

Spinner

Splitter

Stack Layout

Stencil View

Switch

TabbedPanel

Text Input

Toggle button

Tree View

Video

Video player

VKeyboard

Widget class

Utils

Vector

Weak Method

Weak Proxy

Table Of Contents

Spelling

Spelling¶

Provides abstracted access to a range of spellchecking backends as well as
word suggestions. The API is inspired by enchant but other backends can be
added that implement the same API.

Spelling currently requires python-enchant for all platforms except
OSX, where a native implementation exists.

>>> from kivy.core.spelling import Spelling
>>> s = Spelling()
>>> s.list_languages()
['en', 'en_CA', 'en_GB', 'en_US']
>>> s.select_language('en_US')
>>> s.suggest('helo')
[u'hole', u'help', u'helot', u'hello', u'halo', u'hero', u'hell', u'held',
 u'helm', u'he-lo']

class kivy.core.spelling.SpellingBase(language=None)[ソース]¶

ベースクラス: builtins.object

Base class for all spelling providers.
Supports some abstract methods for checking words and getting suggestions.

check(word)[ソース]¶

If word is a valid word in self._language (the currently active
language), returns True. If the word shouldn’t be checked, returns
None (e.g. for ‘’). If it is not a valid word in self._language,
return False.

<col class="field-name" />
<col class="field-body" />

Parameters:

word: str

The word to check.

list_languages()[ソース]¶

Return a list of all supported languages.
E.g. [‘en’, ‘en_GB’, ‘en_US’, ‘de’, ...]

select_language(language)[ソース]¶

From the set of registered languages, select the first language
for language.

<col class="field-name" />
<col class="field-body" />

Parameters:

language: str

Language identifier. Needs to be one of the options returned by
list_languages(). Sets the language used for spell checking and
word suggestions.

suggest(fragment)[ソース]¶

For a given fragment (i.e. part of a word or a word by itself),
provide corrections (fragment may be misspelled) or completions
as a list of strings.

<col class="field-name" />
<col class="field-body" />

Parameters:

fragment: str

The word fragment to get suggestions/corrections for.
E.g. ‘foo’ might become ‘of’, ‘food’ or ‘foot’.

exception kivy.core.spelling.NoSuchLangError[ソース]¶

ベースクラス: Exception

Exception to be raised when a specific language could not be found.

exception kivy.core.spelling.NoLanguageSelectedError[ソース]¶

ベースクラス: Exception

Exception to be raised when a language-using method is called but no
language was selected prior to the call.

                  « Image

                  Text »


text:
using System;
using System.ComponentModel.Composition.Hosting;
using System.Reflection;
using SimpleNet.Sample.Contracts;
using SimpleNet.ServiceHost.Contracts.Address;
using SimpleNet.TraceBroadcastService.Contracts;
using SimpleNet.TraceBroadcastService.Contracts.Adapters;
using SimpleNet.TraceBroadcastService.Contracts.Address;
using SimpleNet.TraceBroadcastService.Contracts.Callback;

namespace SimpleNet.Client.ConsoleApp
{
    class Program
    {
        private static readonly CompositionContainer Container;

        static Program()
        {
            var batch = MefRegistration.GetCompositionBatch();

            Container = MefRegistration.GetCompositionContainer(Assembly.GetExecutingAssembly(), batch);
        }

        static void Main(string[] args)
        {
            var appId = Guid.NewGuid();

            var callback = new DefaultDiagnosticsServicesCallback();
            callback.MessageReceived += delegate(LogMessageDto message)
            {
                Console.WriteLine("Received {0}: {2:d}: {1}", message.LogLevel, message.LogText, message.LogDateTime);
            };

            var serviceAddress =
                Container.GetExportedValue<IWcfServiceAddress>(DiagnosticsAddressProvider.DIAGNOSTICS_SERVICE_ADDRESS);

            var sampleService = Container.GetExportedValue<SampleServiceProxy>();

            var duplexCcasAdapter = new DuplexDiagnosticServiceAdapter(serviceAddress, callback);

            var inLoop = true;

            Console.Clear();

            Console.WriteLine(
                @"Please press
                    C: Connect to Duplex Messaging Service
                    R: Read data from Service
                    Q: Quit
                    ");

            while (inLoop)
            {
                Console.WriteLine("-------------------------------------------");

                var key = Console.ReadKey();

                switch (key.KeyChar.ToString().ToUpperInvariant())
                {
                    case "C":
                        try
                        {
                            Console.WriteLine("Establishing Duplex Connection");

                            duplexCcasAdapter.Connect(appId, "Debug", "secret");
                        }
                        catch (Exception)
                        {
                            Console.WriteLine("Failed! Please try again (takes 2 tries at times) ");
                        }

                        break;
                    case "R":
                        Console.WriteLine(sampleService.GetServiceName());
                        break;
                    case "Q":
                        inLoop = false;
                        break;

                }

            }

            Console.ReadLine();

        }

    }
}


text:
import { BlockNode } from './block';
import { Token } from '../tokenize';
export declare class OrderedListNode extends BlockNode {
    constructor(opts: any);
    appendChild(node: any): void;
    openTag(): string;
    closeTag(): string;
    absorb(child: any): any;
    static matches(token: Token): boolean;
}


text:
const {
  assertSame, assertNotSame, assertTrue, assertFalse
} = Assert;

const root = Reflect.Realm.immutableRoot();
const newRealm = root.spawn();

assertNotSame(root, newRealm);
assertNotSame(root.global, newRealm.global);

assertTrue(Object.isFrozen(root));
assertFalse(Object.isFrozen(newRealm));

assertTrue(Object.isFrozen(root.global));
assertFalse(Object.isFrozen(newRealm.global));

assertSame(root.global, Object.getPrototypeOf(newRealm.global));


text:
<?php

/** Bootstrap for the dicomanonymize module. */
class Dicomanonymize_Bootstrap extends Zend_Application_Module_Bootstrap
{
}


text:
<?php

	$root = dirname(dirname(__FILE__));
	ini_set("include_path", "{$root}/www:{$root}/www/include");

	set_time_limit(0);

	#

	include("include/init.php");

	loadlib("backfill");
	loadlib("flickr_photos");
	loadlib("flickr_photos_search");

	if (! $GLOBALS['cfg']['enable_feature_solr']){
		echo "search indexing is disabled, exiting";
		exit();
	}

	function index_photo($row, $more=array()){
		$photo = flickr_photos_get_by_id($row['id']);
		$rsp = flickr_photos_search_index_photo($photo);
	}

	$sql = "SELECT * FROM FlickrPhotos";
	backfill_db_users($sql, 'index_photo');

	exit();
?>


text:
namespace ui {

// static
bool AXLiveRegionTracker::IsLiveRegionRoot(const AXNode& node) {
  return node.HasStringAttribute(ax::mojom::StringAttribute::kLiveStatus) &&
         node.GetStringAttribute(ax::mojom::StringAttribute::kLiveStatus) !=
             "off";
}

AXLiveRegionTracker::AXLiveRegionTracker(const AXTree& tree) : tree_(tree) {
  DCHECK(tree.root());
  const AXNode& root = *tree.root();
  WalkTreeAndAssignLiveRootsToNodes(root, nullptr);
}

AXLiveRegionTracker::~AXLiveRegionTracker() = default;

void AXLiveRegionTracker::UpdateCachedLiveRootForNode(const AXNode& node) {
  const AXNode* live_root = &node;
  while (live_root && !IsLiveRegionRoot(*live_root))
    live_root = live_root->GetUnignoredParent();

  if (live_root)
    live_region_node_to_root_id_[node.id()] = live_root->id();
}

void AXLiveRegionTracker::OnNodeWillBeDeleted(const AXNode& node) {
  if (AXNode* root = GetLiveRoot(node))
    QueueChangeEventForDeletedNode(*root);

  live_region_node_to_root_id_.erase(node.id());
  deleted_node_ids_.insert(node.id());
}

void AXLiveRegionTracker::QueueChangeEventForDeletedNode(const AXNode& root) {
  live_region_roots_with_changes_.insert(root.id());
}

void AXLiveRegionTracker::OnAtomicUpdateFinished() {
  deleted_node_ids_.clear();
  live_region_roots_with_changes_.clear();
}

AXNode* AXLiveRegionTracker::GetLiveRoot(const AXNode& node) const {
  auto iter = live_region_node_to_root_id_.find(node.id());
  if (iter == live_region_node_to_root_id_.end())
    return nullptr;

  AXNodeID id = iter->second;
  if (deleted_node_ids_.find(id) != deleted_node_ids_.end())
    return nullptr;

  return tree_.GetFromId(id);
}

AXNode* AXLiveRegionTracker::GetLiveRootIfNotBusy(const AXNode& node) const {
  AXNode* live_root = GetLiveRoot(node);
  if (!live_root)
    return nullptr;

  // Don't return the live root if the live region is busy.
  if (live_root->GetBoolAttribute(ax::mojom::BoolAttribute::kBusy))
    return nullptr;

  return live_root;
}

void AXLiveRegionTracker::WalkTreeAndAssignLiveRootsToNodes(
    const AXNode& node,
    const AXNode* current_root) {
  if (IsLiveRegionRoot(node))
    current_root = &node;
  if (current_root)
    live_region_node_to_root_id_[node.id()] = current_root->id();
  for (AXNode* child : node.GetAllChildren())
    WalkTreeAndAssignLiveRootsToNodes(*child, current_root);
}

}  // namespace ui


text:
<?php
require_once 'DB_Functions.php';
$db = new DB_Functions();

// json response array
$response = array("error" => FALSE);

$db->updatePOID($_POST['email'], $_POST['p_o_id']);

?>


text:
package net.imglib2.ops.operation.complex.binary;

import net.imglib2.type.numeric.ComplexType;

//Handbook of Mathematics and Computational Science, Harris & Stocker, Springer, 2006

/**
 * Sets a complex number output to the division of a complex number by a second
 * complex number.
 *
 * @author Barry DeZonia
 * @deprecated Use net.imagej.ops instead.
 */
@Deprecated
public final class ComplexDivide<
		I1 extends ComplexType<I1>,
		I2 extends ComplexType<I2>,
		O extends ComplexType<O>>
	implements ComplexBinaryOperation<I1,I2,O>
{
	@Override
	public O compute(I1 z1, I2 z2, O output) {
		double denom = z2.getRealDouble() * z2.getRealDouble()
				+ z2.getImaginaryDouble() * z2.getImaginaryDouble();
		double x = (z1.getRealDouble() * z2.getRealDouble() + z1
				.getImaginaryDouble() * z2.getImaginaryDouble())
				/ denom;
		double y = (z1.getImaginaryDouble() * z2.getRealDouble() - z1
				.getRealDouble() * z2.getImaginaryDouble())
				/ denom;
		output.setComplexNumber(x, y);
		return output;
	}

	@Override
	public ComplexDivide<I1,I2,O> copy() {
		return new ComplexDivide<I1,I2,O>();
	}

}


text:
package bzh.msansm1.discogsapi.json.search;

/**
 * Created by ronan on 30/09/2016.
 */

public class Community {
    private Integer have;
    private Integer want;

    public Integer getHave() {
        return have;
    }

    public void setHave(Integer have) {
        this.have = have;
    }

    public Integer getWant() {
        return want;
    }

    public void setWant(Integer want) {
        this.want = want;
    }
}


text:
export interface MousePixelDeferral {
    name: string;
    deferPixels: number;
}


text:
const { expect } = require('./spec-helper');
const { MemberElement, ObjectSlice } = require('../lib/minim');

describe('ObjectSlice', () => {
  const thisArg = { message: 42 };

  it('provides map', () => {
    const slice = new ObjectSlice([
      new MemberElement('name', 'Doe'),
    ]);

    const result = slice.map(function map(value) {
      expect(this).to.deep.equal(thisArg);
      return value.toValue();
    }, thisArg);

    expect(result).to.deep.equal(['Doe']);
  });

  it('provides forEach', () => {
    const element = new MemberElement('name', 'Doe');
    const slice = new ObjectSlice([element]);

    const keys = [];
    const values = [];
    const members = [];
    const indexes = [];

    slice.forEach(function forEach(value, key, member, index) {
      keys.push(key.toValue());
      values.push(value.toValue());
      members.push(member);
      indexes.push(index);

      expect(this).to.deep.equal(thisArg);
    }, thisArg);

    expect(keys).to.deep.equal(['name']);
    expect(values).to.deep.equal(['Doe']);
    expect(members).to.deep.equal([element]);
    expect(indexes).to.deep.equal([0]);
  });

  it('provides filter', () => {
    const slice = new ObjectSlice([
      new MemberElement('name', 'Doe'),
      new MemberElement('name', 'Bill'),
    ]);

    const filtered = slice.filter(function filter(value) {
      expect(this).to.deep.equal(thisArg);
      return value.toValue() === 'Doe';
    }, thisArg);

    expect(filtered).to.be.instanceof(ObjectSlice);
    expect(filtered.toValue()).to.deep.equal([{ key: 'name', value: 'Doe' }]);
  });

  it('provides reject', () => {
    const slice = new ObjectSlice([
      new MemberElement('name', 'Doe'),
      new MemberElement('name', 'Bill'),
    ]);

    const filtered = slice.reject(function filter(value) {
      expect(this).to.deep.equal(thisArg);
      return value.toValue() === 'Doe';
    }, thisArg);

    expect(filtered).to.be.instanceof(ObjectSlice);
    expect(filtered.toValue()).to.deep.equal([{ key: 'name', value: 'Bill' }]);
  });

  it('provides keys', () => {
    const element = new MemberElement('name', 'Doe');
    const slice = new ObjectSlice([element]);

    expect(slice.keys()).to.deep.equal(['name']);
  });

  it('provides values', () => {
    const element = new MemberElement('name', 'Doe');
    const slice = new ObjectSlice([element]);

    expect(slice.values()).to.deep.equal(['Doe']);
  });
});


text:
REPORTER ?= spec

test:
	./node_modules/.bin/mocha \
		--compilers js:babel/register \
		--ui bdd \
		--reporter $(REPORTER) \
		--recursive

.PHONY: test


text:
<?xml version="1.0"?>
<menu>

	<game name="cyclshtg" index="true" image="a">
		<description>Cycle Shooting  </description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

	<game name="desertgu" index="true" image="a">
		<description>Desert Gun</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

		<game name="greatgun" index="true" image="a">
		<description>Great Guns  </description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

		<game name="lockload" index="true" image="a">
		<description>Locked 'n Loaded (World)  </description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

		<game name="timecrs2" index="true" image="a">
		<description>Time Crisis 2</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

	<game name="timecrs3" index="true" image="a">
		<description>Time Crisis 3</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

		<game name="hotd" index="true" image="a">
		<description>House of the dead</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

		<game name="hotd2" index="true" image="a">
		<description>House of the dead</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

			<game name="hotdex" index="true" image="a">
		<description>House of the dead EX</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer></manufacturer>
		<year></year>
		<genre>Gun</genre>
		<rating></rating>
		<enabled>Yes</enabled>
	</game>

	<game name="alien3" index="true" image="a">
		<description>Alien3: The Gun (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sega</manufacturer>
		<year>1993</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="area51" index="" image="">
		<description>Area 51 (R3000)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Atari Games</manufacturer>
		<year>1996</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="area51mx" index="" image="">
		<description>Area 51 / Maximum Force Duo v2.0</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Atari Games</manufacturer>
		<year>1998</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="bang" index="true" image="b">
		<description>Bang!</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Gaelco</manufacturer>
		<year>1998</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="bbusters" index="" image="">
		<description>Beast Busters (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>SNK</manufacturer>
		<year>1989</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Life Like Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="borntofi" index="" image="">
		<description>Born To Fight</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>International Games</manufacturer>
		<year>19??</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="bubbletr" index="" image="">
		<description>Bubble Trouble (Japan)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Namco</manufacturer>
		<year>1992</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="carnevil" index="true" image="c">
		<description>CarnEvil (v1.0.3)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Midway Games</manufacturer>
		<year>1998</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="cheyenne" index="" image="">
		<description>Cheyenne (version 1.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Exidy</manufacturer>
		<year>1984</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="chiller" index="" image="">
		<description>Chiller (version 3.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Exidy</manufacturer>
		<year>1986</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="claypign" index="" image="">
		<description>Clay Pigeon (version 2.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Exidy</manufacturer>
		<year>1986</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="combat" index="" image="">
		<description>Combat (version 3.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Exidy</manufacturer>
		<year>1985</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="cracksht" index="" image="">
		<description>Crackshot (version 2.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Exidy</manufacturer>
		<year>1985</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="crossbow" index="" image="">
		<description>Crossbow (version 2.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Exidy</manufacturer>
		<year>1983</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="cryptklr" index="" image="">
		<description>Crypt Killer (GQ420 UAA)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Konami</manufacturer>
		<year>1995</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="deerhunt" index="true" image="d">
		<description>Deer Hunting USA V4.3</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sammy USA Corporation</manufacturer>
		<year>2000</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="dragngun" index="" image="">
		<description>Dragon Gun (US)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Data East Corporation</manufacturer>
		<year>1993</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="pc_duckh" index="" image="">
		<description>Duck Hunt (PlayChoice-10)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Nintendo</manufacturer>
		<year>1984</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="eggventr" index="true" image="e">
		<description>Egg Venture (Release 10)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>The Game Room</manufacturer>
		<year>1997</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="ghoshunt" index="true" image="g">
		<description>Ghost Hunter</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Hanaho Games</manufacturer>
		<year>1996</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="ghlpanic" index="" image="">
		<description>Ghoul Panic (Asia, OB2/VER.A)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Eighting / Raizing / Namco</manufacturer>
		<year>1999</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="gollygho" index="" image="">
		<description>Golly! Ghost!</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Namco</manufacturer>
		<year>1990</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="gunbustr" index="" image="">
		<description>Gunbuster (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Taito Corporation Japan</manufacturer>
		<year>1992</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="hitnmiss" index="true" image="h">
		<description>Hit 'n Miss (version 3.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Exidy</manufacturer>
		<year>1987</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="pc_hgaly" index="" image="">
		<description>Hogan's Alley (PlayChoice-10)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Nintendo</manufacturer>
		<year>1984</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="invasnab" index="true" image="i">
		<description>Invasion - The Abductors (version 5.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Midway</manufacturer>
		<year>1999</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="jdredd" index="true" image="j">
		<description>Judge Dredd (Rev C Dec. 17 1997)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Acclaim</manufacturer>
		<year>1996</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Life Like Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="jpark" index="" image="">
		<description>Jurassic Park</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sega</manufacturer>
		<year>1993</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="lghost" index="true" image="l">
		<description>Laser Ghost (World, FD1094 317-0166)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sega</manufacturer>
		<year>1990</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="lethalen" index="" image="">
		<description>Lethal Enforcers (ver UAE, 11/19/92 15:04)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Konami</manufacturer>
		<year>1992</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="le2" index="" image="">
		<description>Lethal Enforcers II: Gun Fighters (ver EAA)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Konami</manufacturer>
		<year>1994</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="lethalj" index="" image="">
		<description>Lethal Justice</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>The Game Room</manufacturer>
		<year>1996</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Life Like Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="loffire" index="" image="">
		<description>Line of Fire / Bakudan Yarou (World, FD1094 317-0136)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sega</manufacturer>
		<year>1989</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="lordgun" index="" image="">
		<description>Lord of Gun (USA)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>IGS</manufacturer>
		<year>1994</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="maxforce" index="" image="">
		<description>Maximum Force v1.05</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Atari Games</manufacturer>
		<year>1996</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="mechatt" index="" image="">
		<description>Mechanized Attack (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>SNK</manufacturer>
		<year>1989</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="gdfs" index="" image="">
		<description>Mobil Suit Gundam Final Shooting (Japan)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Banpresto</manufacturer>
		<year>1995</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="nycaptor" index="true" image="n">
		<description>N.Y. Captor</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Taito</manufacturer>
		<year>1985</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="oneshot" index="true" image="o">
		<description>One Shot One Kill</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Promat</manufacturer>
		<year>1996</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="othunder" index="" image="">
		<description>Operation Thunderbolt (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Taito Corporation Japan</manufacturer>
		<year>1988</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="opwolf" index="" image="">
		<description>Operation Wolf (World, set 1)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Taito Corporation Japan</manufacturer>
		<year>1987</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="opwolf3" index="" image="">
		<description>Operation Wolf 3 (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Taito Corporation Japan</manufacturer>
		<year>1994</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="ptblank" index="true" image="p">
		<description>Point Blank (World, GN2 Rev B)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Namco</manufacturer>
		<year>1994</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="ptblank2" index="" image="">
		<description>Point Blank 2 (GNB5/VER.A)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Namco</manufacturer>
		<year>1999</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="policetr" index="" image="">
		<description>Police Trainer (Rev 1.3)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>P&P Marketing</manufacturer>
		<year>1996</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="rchase" index="true" image="r">
		<description>Rail Chase (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sega</manufacturer>
		<year>1991</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="rapidfir" index="" image="">
		<description>Rapid Fire v1.1 (Build 239)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Hanaho Games</manufacturer>
		<year>1998</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="revx" index="" image="">
		<description>Revolution X (Rev. 1.0 6/16/94)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Midway</manufacturer>
		<year>1994</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="sshooter" index="true" image="s">
		<description>Sharpshooter (Rev 1.9)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>P&P Marketing</manufacturer>
		<year>1998</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="shootgal" index="" image="">
		<description>Shooting Gallery</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Seatongrove Ltd (Zaccaria license)</manufacturer>
		<year>1984</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="spacegun" index="" image="">
		<description>Space Gun (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Taito Corporation Japan</manufacturer>
		<year>1990</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="sgunner" index="" image="">
		<description>Steel Gunner</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Namco</manufacturer>
		<year>1990</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="sgunner2" index="" image="">
		<description>Steel Gunner 2 (US)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Namco</manufacturer>
		<year>1991</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Animated Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="targeth" index="true" image="t">
		<description>Target Hits (ver 1.1)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Gaelco</manufacturer>
		<year>1994</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="term2" index="" image="">
		<description>Terminator 2 - Judgment Day (rev LA4 08/03/92)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Midway</manufacturer>
		<year>1991</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="tickee" index="" image="">
		<description>Tickee Tickats</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Raster Elite</manufacturer>
		<year>1994</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="timecris" index="" image="">
		<description>Time Crisis (Rev. TS2 Ver.B)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Namco</manufacturer>
		<year>1995</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="triplhnt" index="" image="">
		<description>Triple Hunt</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Atari</manufacturer>
		<year>1977</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="trophyh" index="" image="">
		<description>Trophy Hunting - Bear & Moose V1.0</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sammy USA Corporation</manufacturer>
		<year>2002</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Life Like Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="turkhunt" index="" image="">
		<description>Turkey Hunting USA V1.0</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sammy USA Corporation</manufacturer>
		<year>2001</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="tshoot" index="" image="">
		<description>Turkey Shoot</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Williams</manufacturer>
		<year>1984</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="tutstomb" index="" image="">
		<description>Tut's Tomb</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Island Design</manufacturer>
		<year>1996</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="twinadv" index="" image="">
		<description>Twin Adventure (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Barko Corp.</manufacturer>
		<year>1995</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="undrfire" index="true" image="u">
		<description>Under Fire (World)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Taito Corporation Japan</manufacturer>
		<year>1993</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="duckhunt" index="true" image="v">
		<description>Vs. Duck Hunt (set DH3 E)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Nintendo</manufacturer>
		<year>1985</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="vsfdf" index="" image="">
		<description>Vs. Freedom Force</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sunsoft</manufacturer>
		<year>1988</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="hogalley" index="" image="">
		<description>Vs. Hogan's Alley (set HA4-1 E-1)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Nintendo</manufacturer>
		<year>1985</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="whodunit" index="true" image="w">
		<description>Who Dunit (version 8.0)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Exidy</manufacturer>
		<year>1988</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="pc_wgnmn" index="" image="">
		<description>Wild Gunman (PlayChoice-10)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Nintendo</manufacturer>
		<year>1984</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="wildplt" index="" image="">
		<description>Wild Pilot</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Jaleco</manufacturer>
		<year>1992</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="wschamp" index="" image="">
		<description>Wing Shooting Championship V2.00</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Sammy USA Corporation</manufacturer>
		<year>2001</year>
		<genre>Gun</genre>
		<rating>AAMA - Yellow (Animated Violence Mild)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="zeropnt" index="true" image="z">
		<description>Zero Point (set 1)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Unico</manufacturer>
		<year>1998</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="zeropnt2" index="" image="">
		<description>Zero Point 2</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>Unico</manufacturer>
		<year>1999</year>
		<genre>Gun</genre>
		<rating>AAMA - Green (Suitable For All Ages)</rating>
		<enabled>Yes</enabled>
	</game>
	<game name="zombraid" index="" image="">
		<description>Zombie Raid (US)</description>
		<cloneof></cloneof>
		<crc></crc>
		<manufacturer>American Sammy</manufacturer>
		<year>1995</year>
		<genre>Gun</genre>
		<rating>AAMA - Red (Life Like Violence Strong)</rating>
		<enabled>Yes</enabled>
	</game>
</menu>


text:
module YARD
  module DM
    module Extensions

      protected

      def effected_namespace
        if statement.type == :command_call
          context = statement.jump(:var_ref)

          unless context.source == 'self'
            return ensure_loaded!(
              Registry.resolve(namespace,context.source)
            )
          end
        end

        return namespace
      end

    end
  end
end


text:
A GroupMe clone built using the Meteor framework, and MongoDB.
Powered by Twilio.


text:
require "spec_helper"

RSpec.describe Edits do
  it "has a version number" do
    expect(Edits::VERSION).not_to be nil
  end
end


text:
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

namespace HtmlContainerControl_
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            button1.InnerText = "Loaded!";
            button1.ServerClick += new EventHandler(button1_ServerClick);
        }

        void button1_ServerClick(object sender, EventArgs e)
        {
            button1.InnerText = "Clicked!";
        }
    }
}


text:
package tools.gsf.facade.assetapi.asset;

import com.fatwire.assetapi.common.AssetAccessException;
import com.fatwire.assetapi.data.AssetData;
import com.fatwire.assetapi.data.AssetId;
import com.fatwire.assetapi.data.AttributeData;
import com.fatwire.assetapi.data.BlobObject;
import com.fatwire.assetapi.data.BlobObject.BlobAddress;
import com.fatwire.assetapi.def.AssetTypeDef;
import com.fatwire.assetapi.def.AttributeDef;
import com.fatwire.assetapi.def.AttributeTypeEnum;
import com.fatwire.mda.Dimension;
import tools.gsf.facade.assetapi.AttributeDataUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * This class provides easy access to AssetData, to be used in rendering code in
 * read-only mode. Is is called <tt>TemplateAsset</tt> because the intent is that it is to be used in Templates.

 * It has casting accessors for values of the different
 * attribute types.

 * It must be noted that naming conflicts between flex attribute names and meta
 * attribute names are resolved by giving the meta attribute preference.

 * <pre>
 * {@code
 * TemplateAsset asset = ...;
 * String name = asset.asString("name");
 * }
 * </pre>
 *
 * @author Dolf Dijkstra
 */
public class TemplateAsset {

    private final AssetData delegate;
    private final List<String> metaList = new ArrayList<String>();

    /**
     * @param delegate asset data
     */
    public TemplateAsset(final AssetData delegate) {
        super();
        this.delegate = delegate;
        fillMetaAttributes();
    }

    public AssetData getDelegate() {
        return delegate;
    }

    /**
     * @return the assetid
     * @see com.fatwire.assetapi.data.AssetData#getAssetId()
     */
    public AssetId getAssetId() {
        return delegate.getAssetId();
    }

    /**
     * @return the asset subtype.
     */
    public String getSubtype() {
        return delegate.getAssetTypeDef().getSubtype();
    }

    /**
     * @return the asset type definition
     * @see com.fatwire.assetapi.data.AssetData#getAssetTypeDef()
     */
    public AssetTypeDef getAssetTypeDef() {
        return delegate.getAssetTypeDef();
    }

    /**
     * @param name name of the association
     * @return list of assetids
     * @see com.fatwire.assetapi.data.AssetData#getAssociatedAssets(java.lang.String)
     */
    public List<AssetId> getAssociatedAssets(final String name) {
        return delegate.getAssociatedAssets(name);
    }

    /**
     * @param name name of the association
     * @return the single associated asset.
     * @see com.fatwire.assetapi.data.AssetData#getAssociatedAssets(java.lang.String)
     */
    public AssetId getAssociatedAsset(final String name) {
        List<AssetId> assocs = delegate.getAssociatedAssets(name);
        if (assocs != null && !assocs.isEmpty()) {
            return assocs.get(0);
        }
        return null;
    }

    /**
     * @param name attribute name
     * @return the attribute value
     * @see com.fatwire.assetapi.data.AssetData#getAttributeData(java.lang.String,
     * boolean)
     */
    public Object getAttribute(final String name) {
        AttributeData o = delegate.getAttributeData(name);
        return o == null ? null : o.getData();
    }

    /**
     * @param name the name of the attribute.
     * @return the meta attribute value.
     * @see com.fatwire.assetapi.data.AssetData#getAttributeData(java.lang.String,
     * boolean)
     */
    public Object getMetaAttribute(final String name) {
        AttributeData o = delegate.getAttributeData(name, true);
        return o == null ? null : o.getData();
    }

    /**
     * @param name attribute name
     * @return true is the attribute is defined as single valued.
     */
    public boolean isSingleValued(final String name) {
        AttributeDef ad = delegate.getAssetTypeDef().getAttributeDef(name, true);
        if (ad == null) {
            ad = delegate.getAssetTypeDef().getAttributeDef(name, false);
        }
        return isSingleValued(ad);
    }

    private boolean isSingleValued(final AttributeDef ad) {
        return AttributeDataUtils.isSingleValued(ad);

    }

    private boolean isMetaAttribute(final String name) {
        return this.metaList.contains(name);
    }

    private AttributeData getMetaFirst(final String name) {
        return delegate.getAttributeData(name, isMetaAttribute(name));
    }

    /**
     * @param name attribute name
     * @return attribute as a List
     */
    public List<?> asList(final String name) {
        final AttributeData attr = getMetaFirst(name);

        return AttributeDataUtils.asList(attr);
    }

    /*
     * <pre> INT Integer FLOAT Double STRING String DATE Date MONEY Double LONG
     * Long LARGE_TEXT String ASSET AssetId BLOB BlobObject </pre>
     */

    /**
     * @param name attribute name
     * @return attribute value as a Integer, can be null; please be careful with
     * autoboxing.
     */

    public Integer asInt(final String name) {
        final AttributeData attr = getMetaFirst(name);
        return AttributeDataUtils.asInt(attr);

    }

    /**
     * @param name attribute name
     * @return attribute value as a Date.
     */
    public Date asDate(final String name) {
        final AttributeData attr = getMetaFirst(name);
        return AttributeDataUtils.asDate(attr);
    }

    /**
     * @param name attribute name
     * @return attribute value as a BlobObject.
     */
    public BlobObject asBlob(final String name) {
        final AttributeData attr = getMetaFirst(name);
        return AttributeDataUtils.asBlob(attr);
    }

    /**
     * @param name attribute name
     * @return attribute value as a Float, can be null; please be careful with
     * autoboxing.
     */
    public Float asFloat(final String name) {
        final AttributeData attr = getMetaFirst(name);
        return AttributeDataUtils.asFloat(attr);
    }

    /**
     * @param name attribute name
     * @return attribute value as a Double, can be null; please be careful with
     * autoboxing.
     */
    public Double asDouble(final String name) {
        final AttributeData attr = getMetaFirst(name);
        return AttributeDataUtils.asDouble(attr);
    }

    /**
     * @param name attribute name
     * @return attribute value as a Long, can be null; please be careful with
     * autoboxing.
     */
    public Long asLong(final String name) {
        final AttributeData attr = getMetaFirst(name);
        return AttributeDataUtils.asLong(attr);
    }

    /**
     * @param name attribute name
     * @return attribute value as a AssetId.
     */
    public AssetId asAssetId(final String name) {

        final AttributeData attr = getMetaFirst(name);
        return AttributeDataUtils.asAssetId(attr);
    }

    /**
     * @param name attribute name
     * @return attribute value as a String.
     */
    public String asString(final String name) {
        final AttributeData attr = getMetaFirst(name);
        return AttributeDataUtils.asString(attr);
    }

    /**
     * @param name attribute name
     * @return attribute value as a BlobAddress.
     */
    public BlobAddress asBlobAddress(final String name) {
        final BlobObject blob = asBlob(name);
        return blob == null ? null : blob.getBlobAddress();
    }

    /**
     * Get all the attribute names.
     *
     * @return the name of all the attributes of the asset
     * @see com.fatwire.assetapi.data.AssetData#getAttributeNames()
     */
    public List<String> getAttributeNames() {

        return delegate.getAttributeNames();
    }

    /**
     * Get the type of the attribute.
     *
     * @param name the name of the attribute
     * @return the attribute type
     */
    public AttributeTypeEnum getType(String name) {
        return delegate.getAssetTypeDef().getAttributeDef(name, isMetaAttribute(name)).getType();
    }

    /**
     * Checks if the asset has an attribute by the provided name.
     *
     * @param name the name of trhe attributes.
     * @return true if the asset has an attribute by this name.
     */
    public boolean isAttribute(String name) {
        return getAttributeNames().contains(name);
    }

    /**
     * Gets all the names of the meta attributes.
     *
     * @return the name of all the attributes of the asset
     * @see com.fatwire.assetapi.data.AssetData#getAttributeNames()
     */
    public List<String> getMetaAttributeNames() {

        return metaList;
    }

    private void fillMetaAttributes() {
        for (final AttributeDef def : delegate.getAssetTypeDef().getAttributeDefs()) {
            if (def.isMetaDataAttribute()) {
                metaList.add(def.getName());
            }
        }
    }

    /**
     * @param name attribute name
     * @return list of assetids
     * @throws AssetAccessException asset exception
     * @see com.fatwire.assetapi.data.AssetData#getImmediateParents(java.lang.String)
     */
    public List<AssetId> getImmediateParents(final String name) throws AssetAccessException {
        return delegate.getImmediateParents(name);
    }

    /**
     * @return the parents of the asset
     * @throws AssetAccessException asset exception
     * @see com.fatwire.assetapi.data.AssetData#getParents()
     */
    public List<AssetId> getParents() throws AssetAccessException {
        return delegate.getParents();
    }

    /**
     * @param name attribute name
     * @param meta the asset attributes
     * @return asset attributes
     * @see com.fatwire.assetapi.data.AssetData#getAttributeData(java.lang.String,
     * boolean)
     */
    public AttributeData getAttributeData(final String name, final boolean meta) {
        return delegate.getAttributeData(name, meta);
    }

    /**
     * @return the Dimension holding the locale
     */
    public Dimension getLocale() {
        AttributeData dim = getAttributeData("Dimension", true);
        if (dim == null) {
            return null;
        }
        return AttributeDataUtils.asDimension(dim);
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((delegate == null) ? 0 : delegate.hashCode());
        return result;
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof TemplateAsset)) {
            return false;
        }
        TemplateAsset other = (TemplateAsset) obj;
        if (delegate == null) {
            if (other.delegate != null) {
                return false;
            }
        } else if (!delegate.equals(other.delegate)) {
            return false;
        }
        return true;
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "TemplateAsset [getAssetId()=" + getAssetId() + "]";
    }

}