text:
using Assets.Scripts.Resources;
using Assets.Scripts.SceneManager;
using Dibware.UnityStateManager.Assets.Scripts.StateManager;
using RuleEngine.Engine;
using System;

namespace Dibware.UnityStateManager.Assets.Scripts.SceneManager
{
    /// <summary>
    /// Manages game scene transitions
    /// </summary>
    internal class GameSceneManager
    {
        #region Properties

        /// <summary>
        /// Gets or sets the rule engine.
        /// </summary>
        /// <value>
        /// The rule engine.
        /// </value>
        private RuleEngine<GameSceneTransition> RuleEngine { get; set; }

        /// <summary>
        /// Gets (or privately sets) the identity which indicates the current game scene.
        /// </summary>
        /// <value>The identity of the game scene.</value>
        public GameSceneIdentifier GameSceneIdentifier { get; private set; }

        /// <summary>
        /// Sets the game scene transition failed callback. The parameter contains
        /// </summary>
        /// <value>
        /// The call back to be called if the game scene transition failed.
        /// </value>
        public GameSceneTransitionFailedDelegate GameSceneTransitionFailedCallback { get; set; }

        #endregion

        #region Constructors

        /// <summary>
        /// Prevents a default instance of the <see cref="GameSceneManager"/> class from being created.
        /// </summary>
        private GameSceneManager() { }

        /// <summary>
        /// Initializes a new instance of the <see cref="GameSceneManager"/> class.
        /// </summary>
        /// <param name="ruleEngine">The rule engine.</param>
        public GameSceneManager(RuleEngine<GameSceneTransition> ruleEngine)
        {
            // Guard against a null RuleEngine
            if (ruleEngine == null) { throw new ArgumentNullException("ruleEngine"); }

            // Set the rule engine reference
            RuleEngine = ruleEngine;
        }

        #endregion

        #region Methods

        /// <summary>
        /// Calls the game scenetransition failed call back if required.
        /// </summary>
        /// <param name="failedReason">The failed reason.</param>
        private void CallGameSceneTransitionFailedCallBackIfRequired(string failedReason)
        {
            if (GameSceneTransitionFailedCallback != null)
            {
                GameSceneTransitionFailedCallback(failedReason);
            }
        }

        /// <summary>
        /// Called when the game scene needs to be changed
        /// </summary>
        /// <param name="newGameSceneIdentifier">The new game scene identifier.</param>
        private void OnGameSceneChange(GameSceneIdentifier newGameSceneIdentifier)
        {
            // We will capture the 'Original' scene as we will need to know what
            // it originally was after it has changed
            GameSceneIdentifier originalSceneIdentifier = this.GameSceneIdentifier;

            // Create the game scene transition we are about to make happen and
            // use this in the rule engine to validate that the game scene
            // transition is valid.
            GameSceneTransition sceneTransition =
                new GameSceneTransition(originalSceneIdentifier, newGameSceneIdentifier);
            RuleEngine.ActualValue = sceneTransition;

            // A valid transitoin is one which matches ANY of the rules
            bool isValidTransition = RuleEngine.MatchAny();

            // Check if the transition is valid...
            if (!isValidTransition)
            {
                // It's not so we will check the GameSceneTransitionFailedCallback
                // has a reference and call that with a parameter indicating the reason
                CallGameSceneTransitionFailedCallBackIfRequired(GameSceneTransitionFailedReasons.InvalidTransition);

                // Exit the method
                return;
            }

            // As we intend to raise an event before the same scene is changed
            // in case any subscribers wish to cancel the scene change we need a
            // flag which we can use to signify cancellation. Initially we will
            // assume the game scene wont be cancelled...
            bool cancelled = false;

            // Raise the game scene changing event to give any subscribers chance
            // to cancel this process
            State.GameManager.EventManager.RaiseGameSceneChangingEvent(originalSceneIdentifier, newGameSceneIdentifier, ref cancelled);

            // Check to see if the event was cancelled...
            if (cancelled)
            {
                // ... it was so we will check the GameSceneTransitionFailedCallback
                // has a reference and call that with a parameter indicating the reason
                CallGameSceneTransitionFailedCallBackIfRequired(GameSceneTransitionFailedReasons.CancelledTransition);

                // Exit the method
                return;
            }

            // Getting here indicates that the event was not cancelled, so
            // we can actually set the game scene!
            this.GameSceneIdentifier = newGameSceneIdentifier;

            // Raise the game scene changed event to notify any listeners that
            // the game state has changed.
            State.GameManager.EventManager.RaiseGameSceneChangedEvent(originalSceneIdentifier, newGameSceneIdentifier);
        }

        /// <summary>
        /// Sets the game scene identifier.
        /// </summary>
        /// <param name="gameSceneIdentifier">Game scene identifier.</param>
        public void SetGameScene(GameSceneIdentifier gameSceneIdentifier)
        {
            // First check if the specified game scene identifier differs from
            // the current game scene identifier...
            if (this.GameSceneIdentifier != gameSceneIdentifier)
            {
                // ... it does so call a method to handle any actions we may
                // need to perform when the game scene identifier is changed.
                OnGameSceneChange(gameSceneIdentifier);
            }
        }

        #endregion
    }
}


text:
require "formula"

class Fsharp < Formula
  desc "F#, a functional-first programming language"
  homepage "http://fsharp.org/"
  url "https://github.com/fsharp/fsharp.git", :tag => "3.1.1.32",
    :revision => "a4e1f7111a6d1410df3f33e7205ee34617006b94"

  bottle do
    revision 1
    sha256 "169f82ce3b728aab7b892e5741c113e9edd1b8428a79c2b933fd67c6c8cd80cb" => :yosemite
    sha256 "b7456c760c29aaf9d08a0879e1d988ee557ed487cb23ccfd293fcf0895472403" => :mavericks
    sha256 "069a556dae1420b045acacbe55ecfdfccb0f6179db57be4fd3b29baec9aa9b2d" => :mountain_lion
  end

  depends_on "automake" => :build
  depends_on "autoconf" => :build
  depends_on "pkg-config" => :build
  depends_on "mono"

  def install
    system "./autogen.sh", "--prefix=#{prefix}"
    system "make"
    system "make", "install"
  end

  def post_install
    mono_ver = Formula["mono"].version
    %w|3.0 3.1|.each do |fsharp_ver|
      %w|Microsoft.Portable.FSharp.Targets
         Microsoft.FSharp.Targets|.each do |fsharp_targ|

        tree_dir   = "lib/mono/Microsoft\ SDKs/F\#/#{fsharp_ver}/Framework/v4.5"
        source_dir = File.expand_path "#{prefix}/../../mono/#{mono_ver}/#{tree_dir}"

        # variables:
        #  - tree_dir: the 'convoluted' non-absolute path the the installation, inside mono's prefix
        #  - source_dir: tree_dir, inside mono's prefix, expanded to a full path
        #  - fsharp_targ: the target file (for xbuild)
        mkdir_p source_dir
        ln_sf "#{prefix}/#{tree_dir}/#{fsharp_targ}", "#{source_dir}/#{fsharp_targ}"
      end
    end
  end

  test do
    test_str = "Hello Homebrew"
    # fsharpi and fsharpc needs mono to be in the PATH
    ENV.prepend_path 'PATH', Formula["mono"].bin

    output = shell_output %{echo 'printfn "#{test_str}"; exit 0' | #{bin}/fsharpi}
    assert output.include? test_str

    hello = (testpath/"hello.fs")
    hello.write("printfn \"#{test_str}\"\n")
    compiler_output = shell_output "#{bin}/fsharpc #{hello}"
    # make sure to find the fsharp assemblies even if the user has not set
    # MONO_GAC_PREFIX to HOMEBREW_PREFIX
    ENV["MONO_GAC_PREFIX"] = prefix
    output = shell_output "#{Formula["mono"].bin}/mono hello.exe"
    assert_match test_str, output.strip
  end

  def caveats; <<-EOS.undent
    To run programs built with fsharpc you need to set:
      export MONO_GAC_PREFIX="#{HOMEBREW_PREFIX}"
    EOS
  end
end

redpajama_set_name: RedPajamaGithub


text:
static xcb_connection_t *display;
static xcb_screen_t *screen;
static xcb_window_t root;

xcb_key_symbols_t *key_symbols_table;

ExcCode shortcuts_init(xcb_connection_t *cur_display,
		xcb_screen_t *cur_screen, xcb_window_t cur_root) {
	display = cur_display;
	screen = cur_screen;
	root = cur_root;

	key_symbols_table = xcb_key_symbols_alloc(display);
	if (key_symbols_table == NULL)
		PANIC(ERR_X_REQUEST, "shortcuts_init");
	return 0;
}

void shortcuts_free() {
	xcb_key_symbols_free(key_symbols_table);
}

struct ModifierRecord {
	const char *title;
	int value;
};

struct ModifierRecord modifier_records[] = {
	{"Shift", XCB_MOD_MASK_SHIFT},
	{"CapsLock", XCB_MOD_MASK_LOCK},
	{"Ctrl", XCB_MOD_MASK_CONTROL},
	{"Alt", XCB_MOD_MASK_1},
	{"NumLock", XCB_MOD_MASK_2},
	{"AltLang", XCB_MOD_MASK_3},
	{"Kana", XCB_MOD_MASK_4},
	{"ScrollLock", XCB_MOD_MASK_5},
	{NULL, 0},
};

#define ERR_SHORTCUT_UNKNOWN_MODIFIER "Unknown modifier in shortcut \"%s\""
#define ERR_SHORTCUT_UNKNOWN_KEY "Unknown key \"%s\" in shortcut \"%s\""

ExcCode shortcuts_parse(const char *str, struct Hotkey *res) {
	int word_begin = 0;
	res->modifiers = 0;
	int i;
	for (i = 0; str[i]; i++)
		if (str[i] == '+') {
			int modifier_found = 0;
			int j;
			for (j = 0; modifier_records[j].title != NULL; j++)
				if (!strncmp(str + word_begin, modifier_records[j].title,
						i - word_begin)) {
					modifier_found = 1;
					res->modifiers |= modifier_records[j].value;
					break;
				}
			if (!modifier_found)
				PANIC(ERR_SHORTCUT_UNKNOWN_MODIFIER, str);
			word_begin = i + 1;
		}

	KeySym keysym = XStringToKeysym(str + word_begin);
	if (keysym == NoSymbol)
		PANIC(ERR_SHORTCUT_UNKNOWN_KEY, str + word_begin, str);
	res->keycodes = xcb_key_symbols_get_keycode(key_symbols_table, keysym);
	if (res->keycodes == NULL)
		PANIC(ERR_SHORTCUT_UNKNOWN_KEY, str + word_begin, str);
	return 0;
}

// Modifiers that can be set in addition to required
#define EXTRA_MODIFIERS (XCB_MOD_MASK_LOCK | \
		XCB_MOD_MASK_2 | XCB_MOD_MASK_3 | XCB_MOD_MASK_4 | XCB_MOD_MASK_5)

ExcCode grab_keycode(uint8_t owner_events,
		xcb_keycode_t keycode, unsigned modifiers,
		Window grab_window, uint8_t pointer_mode, uint8_t keyboard_mode) {
	unsigned rem_modifiers = EXTRA_MODIFIERS & ~modifiers;
	// Iterate through all submasks of rem_modifiers and grab key with
	// required modifiers and all variants of combinations of extra modifiers
	for (unsigned submask = rem_modifiers; ;
			submask = (submask - 1) & rem_modifiers) {
		xcb_void_cookie_t cookie = xcb_grab_key_checked(display,
				owner_events, grab_window,
				modifiers | submask, keycode, pointer_mode, keyboard_mode);
		if (xcb_request_check(display, cookie) != NULL)
			PANIC(ERR_X_REQUEST, "grab_keycode");
		if (!submask)
			break;
	}
	return 0;
}

ExcCode grab_hotkey(const struct Hotkey *hotkey) {
	for (int i = 0; hotkey->keycodes[i] != XCB_NO_SYMBOL; i++)
		TRY(grab_keycode(1, hotkey->keycodes[i], hotkey->modifiers, root,
				 XCB_GRAB_MODE_ASYNC,  XCB_GRAB_MODE_ASYNC));
	return 0;
}

volatile sig_atomic_t process;

ExcCode shortcuts_handle_start(const struct Shortcut shortcuts[]) {
	for (int i = 0; shortcuts[i].handler != NULL; i++)
		TRY(grab_hotkey(&shortcuts[i].hotkey));

	process = 1;
	xcb_generic_event_t *event;
	while (process && (event = xcb_wait_for_event(display)) != NULL) {
		pthread_mutex_lock(&control_lock);

		do {
			if ((event->response_type & ~0x80) == XCB_KEY_RELEASE &&
					control_context_get() != NULL) {
				xcb_key_release_event_t *key_release_event =
						(xcb_key_release_event_t *) event;

				for (int i = 0; shortcuts[i].handler != NULL; i++) {
					unsigned modifiers = shortcuts[i].hotkey.modifiers;
					if ((modifiers & key_release_event->state) != modifiers)
						continue;
					for (int j = 0;
							shortcuts[i].hotkey.keycodes[j] != XCB_NO_SYMBOL;
							j++)
						if (key_release_event->detail ==
								shortcuts[i].hotkey.keycodes[j]) {
							shortcuts[i].handler();
							break;
						}
				}
			}
			free(event);
		} while ((event = xcb_poll_for_event(display)) != NULL);

		pthread_mutex_unlock(&control_lock);
	}
	return 0;
}

void shortcuts_handle_stop() {
	process = 0;
}


text:
package no.uio.master.autoscale.message;

import java.io.Serializable;
import java.net.InetAddress;
import java.net.UnknownHostException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Abstraction for messages sent.

 * All messages should contain the senders ip address for internal mapping, and the senders ip
 * address should be read after fetching the object at the receiver-side, since the ip address
 * provided by the InetAddress interface may be an internal address behind a router, e.g.,
 * 192.168.0.10, and therefore not directly accessible.
 *
 * @author andreas
 */
public abstract class AbstractMessage implements Serializable {

	private static final long serialVersionUID = -9156910154465325184L;
	private String senderHost;

	public AbstractMessage() {
	}

	/**
	 * Set sender-host addres / ip address.

	 * @param host
	 */
	public void setSenderHost(String host) {
		this.senderHost = host;
	}

	public String getSenderHost() {
		return this.senderHost;
	}

	@Override
	public String toString() {
		return "Message [senderHost=" + senderHost + "]";
	}

}


text:
import Ember from 'ember';
import ClassPrefix from '../mixins/class-prefix';
import layout from '../templates/components/sl-span';

/**
 * @module
 * @augments ember/Component
 */
export default Ember.Component.extend( ClassPrefix, {

    // -------------------------------------------------------------------------
    // Dependencies

    // -------------------------------------------------------------------------
    // Attributes

    /** @type {String[]} */
    classNameBindings: [
        'componentClassName',
        'inverse',
        'loading:sl-loading'
    ],

    /** @type {Object} */
    layout,

    /** @type {String} */
    tagName: 'span',

    // -------------------------------------------------------------------------
    // Actions

    // -------------------------------------------------------------------------
    // Events

    // -------------------------------------------------------------------------
    // Properties

    /**
     * Component class that will be prefixed with base component class
     *
     * @type {String}
     */
    componentClass: 'span',

    /**
     * Whether "inverse" class should be applied (only for sl-loading in this context)
     *
     * @type {Boolean}
     */
    inverse: false,

    /**
     * Whether to show the loading icon or content
     *
     * @type {Boolean}
     */
    loading: false,

    /**
     * The value to display once loaded/ready
     *
     * @type {?String}
     */
    value: null

    // -------------------------------------------------------------------------
    // Observers

    // -------------------------------------------------------------------------
    // Methods

});


text:
namespace content {

class InputHandlerManager;

// CompositorMusConnection manages the connection to the Mandoline UI Service
// (Mus) on the compositor thread. For operations that need to happen on the
// main thread, CompositorMusConnection deals with passing information across
// threads. CompositorMusConnection is constructed on the main thread. By
// default all other methods are assumed to run on the compositor thread unless
// explicited suffixed with OnMainThread.
class CONTENT_EXPORT CompositorMusConnection
    : NON_EXPORTED_BASE(public mus::WindowTreeDelegate),
      NON_EXPORTED_BASE(public mus::InputEventHandler),
      public base::RefCountedThreadSafe<CompositorMusConnection> {
 public:
  // Created on main thread.
  CompositorMusConnection(
      int routing_id,
      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
      const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
      mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request,
      InputHandlerManager* input_handler_manager);

  // Attaches the provided |surface_binding| with the mus::Window for the
  // renderer once it becomes available.
  void AttachSurfaceOnMainThread(
      std::unique_ptr<mus::WindowSurfaceBinding> surface_binding);

 private:
  friend class CompositorMusConnectionTest;
  friend class base::RefCountedThreadSafe<CompositorMusConnection>;

  ~CompositorMusConnection() override;

  void AttachSurfaceOnCompositorThread(
      std::unique_ptr<mus::WindowSurfaceBinding> surface_binding);

  void CreateWindowTreeConnectionOnCompositorThread(
      mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request);

  void OnConnectionLostOnMainThread();

  void OnWindowInputEventOnMainThread(
      std::unique_ptr<blink::WebInputEvent> web_event,
      const base::Callback<void(mus::mojom::EventResult)>& ack);

  void OnWindowInputEventAckOnMainThread(
      const base::Callback<void(mus::mojom::EventResult)>& ack,
      mus::mojom::EventResult result);

  // WindowTreeDelegate implementation:
  void OnConnectionLost(mus::WindowTreeConnection* connection) override;
  void OnEmbed(mus::Window* root) override;
  void OnEventObserved(const ui::Event& event, mus::Window* target) override;

  // InputEventHandler implementation:
  void OnWindowInputEvent(
      mus::Window* window,
      const ui::Event& event,
      std::unique_ptr<base::Callback<void(mus::mojom::EventResult)>>*
          ack_callback) override;

  const int routing_id_;
  mus::Window* root_;
  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
  scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
  InputHandlerManager* const input_handler_manager_;
  std::unique_ptr<mus::WindowSurfaceBinding> window_surface_binding_;

  DISALLOW_COPY_AND_ASSIGN(CompositorMusConnection);
};

}  // namespace content

#endif  // CONTENT_RENDERER_MUS_COMPOSITOR_MUS_CONNECTION_H_


text:
package br.org.arquitetura.model.persistence.dao;

import java.io.Serializable;
import java.util.List;

import br.org.arquitetura.excecao.EntidadeJaExisteExcecao;
import br.org.arquitetura.excecao.EntidadeNaoEncontradaExcecao;

/**
 * Interface padrão de um DAO.
 *
 * @param <E>
 *            tipo da Entidade.
 * @param <P>
 *            tipo da chave primária da Entidade.
 */
public interface IDao<E, P extends Serializable> {

    /**
     * Adiciona um registro da Entidade na base de dados.
     *
     * @param entidade
     *            a Entidade a ser adicionada na base.
     * @return um objeto gerenciado da Entidade adicionada.
     * @throws EntidadeJaExisteExcecao
     *             se a Entidade já existir na base.
     */
    E adicionar(E entidade) throws EntidadeJaExisteExcecao;

    /**
     * Lista todos os registros da Entidade que existem na base da dados.
     *
     * @return uma lista com os registros da Entidade.
     */
    List<E> listar();

    /**
     * Remove uma Entidade da base de dados.
     *
     * @param entidade
     *            a Entidade a ser removida.
     * @throws EntidadeNaoEncontradaExcecao
     *             se a Entidade não for encontrada para remoção.
     */
    void remover(E entidade) throws EntidadeNaoEncontradaExcecao;

    /**
     * Remove uma Entidade a partir da chave primária.
     *
     * @param chavePrimaria
     *            a chave primária da Entidade a ser removida.
     * @throws EntidadeNaoEncontradaExcecao
     *             se a Entidade correspondente à chave primária não for encontrada.
     */
    void remover(P chavePrimaria) throws EntidadeNaoEncontradaExcecao;

    /**
     * Atualiza o registro de uma Entidade na base de dados.
     *
     * @param entidade
     *            a Entidade gerenciada a ser atualizada na base.
     * @return um objeto gerenciado da Entidade atualizada.
     * @throws EntidadeNaoEncontradaExcecao
     *             se a Entidade não for encontrada na base para atualização.
     * @throws EntidadeJaExisteExcecao
     *             se ocorrer violação de constraint.
     */
    E atualizar(E entidade) throws EntidadeNaoEncontradaExcecao, EntidadeJaExisteExcecao;

    /**
     * Recupera uma Entidade da base de dados a partir da chave primária.
     *
     * @param chavePrimaria
     *            a chave primária da Entidade a ser recuperada.
     * @return um objeto gerenciado da Entidade recuperada.
     * @throws EntidadeNaoEncontradaExcecao
     *             se a Entidade não for encontrada na base.
     */
    E recuperar(P chavePrimaria) throws EntidadeNaoEncontradaExcecao;

}


text:
LanguageExtAdornment
====================


text:
package com.a.eye.gemini.sniffer;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import com.a.eye.gemini.sniffer.matcher.SnifferData;
import com.a.eye.gemini.sniffer.producer.GeminiProducer;
import com.a.eye.gemini.sniffer.util.IdWorker;

public class StressAnalysisTest {

	private static final IdWorker worker = new IdWorker(1, 1);

	private static long timezone = 8 * 60 * 60 * 1000;

	private static ProducerRecord<Long, byte[]> record;

	private static int i = 0;
	private static boolean isContinue = true;

	public static void main(String[] args) throws InterruptedException {
		int sleepTime = 200;
		if (args != null && args.length > 0) {
			sleepTime = Integer.valueOf(args[0]);
		}

		SnifferData SnifferData = new SnifferData();
		while (true) {
			System.out.println("#########################################");
			StressAnalysisTest.stressing(SnifferData, sleepTime);
			isContinue = true;
			i = 0;
		}
	}

	public static void stressing(SnifferData snifferData, int sleepTime) throws InterruptedException {
		long start = System.currentTimeMillis();
		while (isContinue) {
			long now = System.currentTimeMillis();
			long workId = worker.nextId();
			snifferData.setReqHost("home.asiainfo.com");
			snifferData.setReqRequesturl("/xiao_jun_0820/article/details/46911775");
			snifferData.setReqTcpSeq(String.valueOf(workId));
			snifferData.setReqTcpTime(String.valueOf(now - timezone));

			byte[] data = snifferData.encode();

			GeminiProducer producer = new GeminiProducer();
			record = new ProducerRecord<Long, byte[]>("gemini-sniffer-topic", workId, data);
			producer.getProducer().send(record, new Callback() {
				public void onCompletion(RecordMetadata metadata, Exception e) {
					if (e != null)
						e.printStackTrace();
				}
			});
			snifferData.clear();
			i++;
			if (i % 10000 == 0) {
				System.out.println(i);
				Thread.sleep(sleepTime);
			}
			if (i == 100000) {
				isContinue = false;
			}
		}
		long end = System.currentTimeMillis();
		System.out.println((end - start) / 1000);
	}
}


text:
<?php namespace Tempest\Database;

use JsonSerializable;

/**
 * A single row from a database query.
 *
 * @author Marty Wallace
 */
class Row implements JsonSerializable {

	/** @var array */
	private $_data = [];

	public function __construct() {
		foreach ($this as $column => $value) {
			if (!in_array($column, ['_data'])) {
				$this->_data[$column] = $value;
			}
		}
	}

	public function __get($prop) {
		return $this->getValue($prop);
	}

	public function __isset($prop) {
		return $this->hasColumn($prop);
	}

	/**
	 * Get the column names attached to this row.
	 *
	 * @return string[]
	 */
	public function getColumns() {
		return array_keys($this->_data);
	}

	/**
	 * Determine whether this row contains a specified column.
	 *
	 * @param string $column The column to check for.
	 *
	 * @return bool
	 */
	public function hasColumn($column) {
		return array_key_exists($column, $this->_data);
	}

	/**
	 * Get the values attached to this row.
	 *
	 * @return string[]
	 */
	public function getValues() {
		return $this->_data;
	}

	/**
	 * Get a value from the row.
	 *
	 * @param string $column The column name.
	 * @param mixed $fallback A fallback value to provide if the column does not exist.
	 *
	 * @return mixed
	 */
	public function getValue($column, $fallback = null) {
		return $this->hasColumn($column) ? $this->_data[$column] : $fallback;
	}

	public function jsonSerialize() {
		return $this->_data;
	}

}


text:
/**
 *
 */
package com.unitedgasket.fulcrum.Fulcrum.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Locale;
import java.util.Properties;

import com.dropbox.core.DbxAppInfo;
import com.dropbox.core.DbxAuthFinish;
import com.dropbox.core.DbxClient;
import com.dropbox.core.DbxEntry;
import com.dropbox.core.DbxException;
import com.dropbox.core.DbxRequestConfig;
import com.dropbox.core.DbxWebAuthNoRedirect;
import com.unitedgasket.fulcrum.Fulcrum.core.FulcrumResources;

/**
 *
 *
 * @author Michael Massarelli
 */
public class HttpUtils {
    public static final String TAG = "HttpUtils";
    static String url = "https://www.dropbox.com/s/asrd9c3i08v8v4y/aesthetica.zip?dl=0";

    public static void downloadIconPack() {
	try {
	    Properties prop = new Properties();
	    File f = FulcrumResources.getCfg("dropbox.properties");
	    InputStream in = new FileInputStream(f);
	    prop.load(in);

	    DbxAppInfo appInfo = new DbxAppInfo(prop.getProperty("key"), prop.getProperty("secret"));

	        DbxRequestConfig config = new DbxRequestConfig("JavaTutorial/1.0",
	            Locale.getDefault().toString());
	        DbxWebAuthNoRedirect webAuth = new DbxWebAuthNoRedirect(config, appInfo);

	        // Have the user sign in and authorize your app.
	        String authorizeUrl = webAuth.start();
	        System.out.println("1. Go to: " + authorizeUrl);
	        System.out.println("2. Click \"Allow\" (you might have to log in first)");
	        System.out.println("3. Copy the authorization code.");
	        String code = new BufferedReader(new InputStreamReader(System.in)).readLine().trim();

	        // This will fail if the user enters an invalid authorization code.
	        DbxAuthFinish authFinish = webAuth.finish(code);
	        String accessToken = authFinish.accessToken;

	        DbxClient client = new DbxClient(config, accessToken);

	        System.out.println("Linked account: " + client.getAccountInfo().displayName);

	        DbxEntry.WithChildren listing = client.getMetadataWithChildren("/");
	        System.out.println("Files in the root path:");
	        for (DbxEntry child : listing.children) {
	            System.out.println("	" + child.name + ": " + child.toString());
	        }

	        FileOutputStream outputStream = new FileOutputStream("fulcrum.txt");
	        try {
	            DbxEntry.File downloadedFile = client.getFile("/Fulcrum/resources/fulcrum.txt", null,
	                outputStream);
	            System.out.println("Metadata: " + downloadedFile.toString());
	        } finally {
	            outputStream.close();
	        }
	} catch (IOException | DbxException e) {

	}
    }

    public static void main(String[] args) {
	downloadIconPack();
    }
}


text:
FROM nginx:1.11
MAINTAINER Mark Shust <mark.shust@mageinferno.com>

ENV PHP_HOST phpfpm
ENV PHP_PORT 9000
ENV APP_MAGE_MODE default

COPY ./conf/nginx.conf /etc/nginx/
COPY ./conf/default.conf /etc/nginx/conf.d/
COPY ./bin/start.sh /usr/local/bin/start.sh

WORKDIR /var/www/html

CMD ["/usr/local/bin/start.sh"]


text:
<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:wikidot="http://www.wikidot.com/rss-namespace">

	<channel>
		<title>Fletch help</title>
		<link>http://bvs.wikidot.com/forum/t-90039/fletch-help</link>
		<description>Posts in the discussion thread "Fletch help" - I have a question about getting Fletch.</description>
				<copyright></copyright>
		<lastBuildDate>Sun, 10 Jul 2022 05:57:17 +0000</lastBuildDate>

					<item>
				<guid>http://bvs.wikidot.com/forum/t-90039#post-262973</guid>
				<title>Re: Fletch help</title>
				<link>http://bvs.wikidot.com/forum/t-90039/fletch-help#post-262973</link>
				<description></description>
				<pubDate>Thu, 18 Sep 2008 16:46:52 +0000</pubDate>
				<wikidot:authorName>MRUhlir</wikidot:authorName>				<wikidot:authorUserId>145588</wikidot:authorUserId>				<content:encoded>
					<![CDATA[

Yes, since it's an A-rank reaper mission.

				 	]]>
				</content:encoded>							</item>
					<item>
				<guid>http://bvs.wikidot.com/forum/t-90039#post-262896</guid>
				<title>Re: Fletch help</title>
				<link>http://bvs.wikidot.com/forum/t-90039/fletch-help#post-262896</link>
				<description></description>
				<pubDate>Thu, 18 Sep 2008 15:12:08 +0000</pubDate>
				<wikidot:authorName>Anonymous</wikidot:authorName>								<content:encoded>
					<![CDATA[

So in other words, I need to be a Jonin to unlock Fletch's mission?

				 	]]>
				</content:encoded>							</item>
					<item>
				<guid>http://bvs.wikidot.com/forum/t-90039#post-262795</guid>
				<title>Re: Fletch help</title>
				<link>http://bvs.wikidot.com/forum/t-90039/fletch-help#post-262795</link>
				<description></description>
				<pubDate>Thu, 18 Sep 2008 13:05:46 +0000</pubDate>
				<wikidot:authorName>MRUhlir</wikidot:authorName>				<wikidot:authorUserId>145588</wikidot:authorUserId>				<content:encoded>
					<![CDATA[

You must be jonin to get A-ranks. Lucky too, but not being a jonin takes the luck out of it.

				 	]]>
				</content:encoded>							</item>
					<item>
				<guid>http://bvs.wikidot.com/forum/t-90039#post-262782</guid>
				<title>Fletch help</title>
				<link>http://bvs.wikidot.com/forum/t-90039/fletch-help#post-262782</link>
				<description></description>
				<pubDate>Thu, 18 Sep 2008 12:39:38 +0000</pubDate>
				<wikidot:authorName>Anonymous</wikidot:authorName>								<content:encoded>
					<![CDATA[

I can easily get Fletch since I'm a White Eye and I can make the requirements quite easily but I haven't gotten his mission once so far. Also, do you have to be a Jonin for his mission to unlock or just lucky?

				 	]]>
				</content:encoded>							</item>
				</channel>
</rss>


text:
(function poll() {
  if (ynabToolKit.pageReady === true && typeof ynabToolKit.shared.feedChanges !== 'undefined') {

    // When this is true, the feature scripts will know they can use the mutationObserver
    ynabToolKit.actOnChangeInit = {};

    // Set 'ynabToolKit.debugNodes = true' to print changes the mutationObserver sees
    // during page interactions and updates to the developer tools console.
    ynabToolKit.debugNodes = false;

    ynabToolKit.actOnChange = function() {

      MutationObserver = window.MutationObserver || window.WebKitMutationObserver;

      var observer = new MutationObserver(function(mutations, observer) {

        if (ynabToolKit.debugNodes) {
          console.log('MODIFIED NODES');
        }

        ynabToolKit.changedNodes = new Set();

        mutations.forEach(function(mutation) {
          var newNodes = mutation.target;
          if (ynabToolKit.debugNodes) {
            console.log(newNodes);
          }

          var $nodes = $(newNodes); // jQuery set
          $nodes.each(function() {
            var $node = $(this);

            try {
              nodeClasses = new Set($node[0].className.split(' '));
            } catch(err) {
              ynabToolKit.debugNodes.errors = err
            }

            ynabToolKit.changedNodes = new Set([...ynabToolKit.changedNodes, ...nodeClasses]);

          }); // each node mutation event

        }); // each mutation event

        if (ynabToolKit.debugNodes) {
          console.log('###')
        }

        // Now we are ready to feed the change digest to the
        // automatically setup feedChanges file/function
        ynabToolKit.shared.feedChanges(ynabToolKit.changedNodes);

      });

      // This finally says 'Watch for changes' and only needs to be called the one time
      observer.observe($('.ember-view.layout')[0], {
        subtree : true,
        childList : true,
        characterData : true,
        attributeFilter : [ 'class' ]
      });

      ynabToolKit.actOnChangeInit = true;
    };
    ynabToolKit.actOnChange(); // Run itself once

  } else {
    setTimeout(poll, 250);
  }
})();


text:
#ifndef _APP_COMMON_FLAGS_H_
#define _APP_COMMON_FLAGS_H_

/** @brief  Config local address type: 0-pulic address, 1-static random address */
#define F_BT_LE_USE_STATIC_RANDOM_ADDR      0

#endif