text:
<!DOCTYPE html>

    <meta charset="UTF-8">

    <title>The Secret Chamber- Dallas Fort Worth Escape Room</title>
    <meta name="google-site-verification" content="36phB56--4LRnl5SACn7Kpt-_LNoaqn-uBjRT9JPrcM" />

    <meta http-equiv="X-UA-Compatible" content="IE=edge" />

    <meta name="viewport" content="width=device-width,initial-scale=1">

    <meta name="copyright" content="Copyright 2015 The Secret Chambers, llc. All rights reserved.">
    <meta name="description" content="DFW Dallas Fort Worth escape room entertainment.The Secret Chambers is a escape room challenge business. Unlock the secrets to a fun interactive and immersive entertainment experience">
    <meta name="keywords" content="escape, room, challenge, fun, team, puzzle, secret, clues, pirate, escaperoom, cthulhu, steampunk">

    <link rel="author" href="https://plus.google.com/+TallerConcepts">
    <link rel="publisher" href="https://plus.google.com/+TallerConcepts">

    <meta name="twitter:card" content="photo">
    <meta name="twitter:site" content="http://www.thesecretchambers.com">
    <meta name="twitter:title" content="The Secret Chambers">
    <meta name="twitter:description" content="The Secret Chambers is the premier Dallas Fort Worth DFW escape room challenge. Unlock the secrets to a fun interactive and immersive entertainment experience. Great for celebrations, team building, dates, or just a good time">
    <meta name="twitter:image" content="http://www.thesecretchambers.com/img/icons/sc/196x196.png">
    <meta name="twitter:url" content="https://twitter.com/TSCEscapeRoom">

    <meta property="og:title" content="The Secret Chambers">
    <meta property="og:type" content="activity">
    <meta property="og:url" content="http://www.thesecretchambers.com">
    <meta property="og:image" content="http://www.thesecretchambers.com/img/icons/sc/196x196.png">
    <meta property="og:site_name" content="Secret Chambers">

    <meta property="og:description" content="The Secret Chambers is the premier Dallas Fort Worth DFW escape room challenge. Unlock the secrets to a fun interactive and immersive entertainment experience. Great for celebrations, team building, dates, or just a good time">

    <meta name="designer" content="Taller Concepts, support@tallerconcepts.com" />

    <link rel="canonical" href="http://www.thesecretchambers.com">

    <link rel="dns-prefetch" href="http://thesecretchambers.com">

    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <meta name="format-detection" content="telephone=yes">

    <link rel="apple-touch-icon" sizes="57x57" href="http://thesecretchambers.com/img/icons/sc/apple-icon-57x57.png">
    <link rel="apple-touch-icon" sizes="60x60" href="http://thesecretchambers.com/img/icons/sc/apple-icon-60x60.png">
    <link rel="apple-touch-icon" sizes="72x72" href="http://thesecretchambers.com/img/icons/sc/apple-icon-72x72.png">
    <link rel="apple-touch-icon" sizes="76x76" href="http://thesecretchambers.com/img/icons/sc/apple-icon-76x76.png">
    <link rel="apple-touch-icon" sizes="114x114" href="http://thesecretchambers.com/img/icons/sc/apple-icon-114x114.png">
    <link rel="apple-touch-icon" sizes="120x120" href="http://thesecretchambers.com/img/icons/sc/apple-icon-120x120.png">
    <link rel="apple-touch-icon" sizes="144x144" href="http://thesecretchambers.com/img/icons/sc/apple-icon-144x144.png">
    <link rel="apple-touch-icon" sizes="152x152" href="http://thesecretchambers.com/img/icons/sc/apple-icon-152x152.png">
    <link rel="apple-touch-icon" sizes="180x180" href="http://thesecretchambers.com/img/icons/sc/apple-icon-180x180.png">
    <link rel="icon" type="image/png" sizes="192x192" href="http://thesecretchambers.com/img/icons/sc/android-icon-192x192.png">
    <link rel="icon" type="image/png" sizes="32x32" href="http://thesecretchambers.com/img/icons/sc/favicon-32x32.png">
    <link rel="icon" type="image/png" sizes="96x96" href="http://thesecretchambers.com/img/icons/sc/favicon-96x96.png">
    <link rel="icon" type="image/png" sizes="16x16" href="http://thesecretchambers.com/img/icons/sc/favicon-16x16.png">
    <link rel="manifest" href="http://thesecretchambers.com/manifest.json">
    <meta name="msapplication-TileColor" content="#ffffff">
    <meta name="msapplication-TileImage" content="http://thesecretchambers.com/img/icons/sc/ms-icon-144x144.png">
    <meta name="theme-color" content="#ffffff">
    <link rel="alternate" href="http://thesecretchambers.com" hreflang="en-us" />
    <link href="css/fontawesome.css" rel="stylesheet">
    <link href="css/bootstrap.min.css" rel="stylesheet">
    <link href="css/animate.css" rel="stylesheet">
    <link href="css/main.css" rel="stylesheet">
    <link href="css/benchanges.css" rel="stylesheet">

                    <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#custom-collapse">
                        Toggle navigation

                    </button>

                        "Engage your mind & the key you will find"

Home

How it works

                          Rooms

Pirate

Cthulhu

FAQ

Book Now

Contact Us

                            Get Directions

                What is an escape room?
                Why choose us?
                Want to book a room?
                Where are we located?

Why Choose Us?

Escape Rooms are one of the fastest growing industries in the world, and they are quickly becoming homogenous.

The Secret Chambers is pushing the cutting edges of innovation to provide a more fully immersive experience than any other Escape Room in the world.  Here's how:

- Completely original room concepts and stories

- A deeper premise, setting, and storyline

- Professionally trained and experienced Live action actors who interact with the customers and provide dramatic in-game events

- Multisensory stimulation through event-timed sound effects, setting-specific scents, and stunning visuals

- Mechanical moving parts that activate remotely, providing a multitude of surprises and "wow!" moments

- Plenty of "secret chambers" to discover, revealing previously undiscovered areas that change the dynamics of the room

- An overarching plot that slowly reveals new secrets as customers complete more and more rooms

(DFW) Dallas Fort Worth escape room

How Our Escape Room Works

Your team will have 60 minutes to find the clues, crack the codes, solve the puzzles, complete the challenges and escape! Use cunning deduction and teamwork in an adrenaline filled race to beat the clock!

Grab some friends

Book online

Show up for your time slot

Use the clues to solve the puzzles

Escape the room in under 60 minutes

Still not sure how it works?

Pick a Room

The Pirate Room

                            You've snuck into the captain's quarters while the pirates are away. Solve the clues to collect all the pieces of the treasure map and escape before the pirates return and catch you!

 Recommended Group Size: 4 to 8, but 2 to 10 allowed

Difficulty: 2 (74% of groups escape)

 Duration: 60 minutes

 Price: $25 a person

 Objective: Work together as a team to find five pieces of a treasure map and escape the ship in under 60 minutes.

 Setting:  The year is 1788.  You are in the captain's quarters of Blackbeard the pirate, aboard his pirate ship while it sits at port.

                            Join the Mailing list
 for updates, offers & rewards

Book Now

</rh>

The Cthulhu Room

                            You've snuck into the Cthulhu's quarters while the Cthulhu are away. Solve the clues to collect all the pieces of the treasure map and escape before the Cthulhu return and catch you!

Recommended Group Size: 4 to 8, but 2 to 10 allowed

Difficulty: 2 (67% of groups escape)

 Duration: 60 minutes

 Price: $25 a person

 Objective: Work together as a team to find five statues, us them to unlock an artifact, and use it to save humanity in under 60 minutes.

 Setting: The year is 1946, in the private study of Taylor Ashford.

                            Join the Mailing list
 for updates, offers & rewards

Book Now

FAQ

How many people?

5-10 people per room per session. If you have less than 5 people give us a call and we'll try to make accommodations.

Special session

Have more than 8 people? Want to participate outside our normal hours? We love special events, give us a call and we'll try to make accomodations

Recommended age

We recommend ages 16 and up and all groups must have at least person over 21. No children under 12 will be admitted.

How hard is it?

We provide a challenging but fair experience that requires no special skills other than teamwork. We guarantee you'll have a lot of fun.

When should I arrive?

Please arrive at least 15 minutes early. If you're late and the session behind yours is booked, we must deduct the time from your session.

What if I get stuck?

If you signal us, we'll give you a clue. Above all, we want you to have fun.

Book Now

                                Hours

                                Schedule

Schedule -
        ————  2 images with 2 text fields with them
        1.)
        2.)

Hours - Our hours are based on bookings. If you see an open time slot that means we're open to be booked.
        ————1 image

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

Hours

Our hours are based on bookings. If you see a open time slot that means were open to be booked.

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

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

Schedule

View our available slots for any day by selecting a room below and clicking on a calendar day

 Select the room you wish to escape. * Cthulhu or Pirate Room

Then select the day and time you want to book. * Note that if their are no times that means we're booked out for that date

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

                            Want to purchase a Voucher?

Please scroll back down after you click

                           Want to redeem a Voucher?

Please scroll back down after you click

See What Others Are Saying

Contact Us

                        <form action="http://formspree.io/info@thesecretchambers.com" method="POST" id="contact-form" role="form">

                                    Name
                                    <input type="text" id="c_name" class="form-control" name="c_name" placeholder="Name">

                                    Email
                                    <input type="email" id="c_email" class="form-control" name="c_email" placeholder="E-mail">

                                    <textarea class="form-control" id="c_message" name="c_message" rows="7" placeholder="Message"></textarea>

                                <button type="submit" class="btn btn-lg btn-block btn-primary" data-wow-delay=".3s" style="visibility: visible; animation-delay: 0.3s; -webkit-animation-delay: 0.3s; animation-name: fadeInUp; -webkit-animation-name: fadeInUp;">Send Message</button>

                        </form>

Please contact us if you have any questions about our Rooms or Prices, we can arrange group bookings, special events and parties. Make reservations online or call us for phone bookings!

  2350 Mall Circle, Fort Worth, TX 76116

  +1 (888) 669-9998

  Support@TheSecretChambers.com

  Click here for directions

Check out The Secret Chambers Escape Challenge on Yelp

                            © 2015 The Secret Chambers | Developed: Taller Concepts & Hosted: Taller host


text:
"""
BlameThrower

Library code for parsing static analysis results and revision control
attribution information.
"""

from collections import namedtuple, defaultdict
import itertools
import warnings

import blamethrower.analyzers
import blamethrower.reporeaders

__all__ = ['Analyne', 'getanalyzers', 'getreporeaders', 'getbugs', 'getblame', 'merge', 'read_analynes', 'getmodule', 'itergroup', 'NoOneToBlameWarning']
__version__ = "0.7.0"

#: A `namedtuple` describing a line of code: file, linenum, bugtype, severity, author
#: `file` is a filename string (including any path)
#: `linenum` is an int line number
#: `bugtype` is a string categorizing a bug
#: `severity` is the severity of a bug: one of 'high', 'med', 'low'
#: `author` is the author of the line
Analyne = namedtuple('Analyne', 'filename linenum bugtype severity author')        # pylint: disable=C0103

def getanalyzers():
    """:Return: the names of available static analyzers.

    :rtype: tuple(str)
    """
    return tuple(blamethrower.analyzers.__all__)

def getreporeaders():
    """:Return: the names of available repository readers.

    :rtype: tuple(str)
    """
    return tuple(blamethrower.reporeaders.__all__)

def getbugs(analyzer_name, bugsfile, **options):
    """:Return: An iterator over :class:`Analyne` tuples for the bugs found
    in `bugsfile`.

    :param str analyzer_name: The name of the module to use to read `bugsfile`.
    :param dict(str,str) options: Any keyword options to pass to the `analyze`
      method.
    """
    analyzer = getmodule("blamethrower.analyzers", analyzer_name)
    if not analyzer:
        raise ValueError("Unknown analysis file type '{0}'".format(analyzer_name))
    return blamethrower.analyzers._check_analyzer_output(analyzer.analyze(bugsfile, **options))

def getblame(repo_name, blamefile, **options):
    """:Return: a dict mapping a filename to a list of authors.

    :param str repo_name: The name of the module to use to read `blamefile`.
    :param file blamefile: VCS "blame" output from VCS `repo_name`.
    :param dict(str,str) options: Any keyword arguments for the `read` method.
    :rtype: dict(str: list(str))
    """
    reporeader = getmodule("blamethrower.reporeaders", repo_name)
    if not reporeader:
        raise ValueError("Unknown repo file type '{0}'".format(repo_name))
    return blamethrower.reporeaders._check_reporeader_output(reporeader.read(blamefile, **options))

def merge(bugs=None, blame=None):
    """:Return: an iterator over :class:`Analyne` namedtuples with all information
    on the given `bugs` and/or `blame`.

    Note there can be multiple outputs for the same line if it has multiple bugs.
    If `blame` is given and a bug has no author, the bug is returned without an author
    and a :exc:`NoOneToBlameWarning` is raised.  In particular, note that some analyzers give bugs
    for lines that don't actually exist.
    :param iter(Analyne) bugs: Iterator over Analyne namedtuples from :func:`getbugs`.
    :param iter((str, list(str))) blame: an iterable of ``(filename,  authorlist)`` pairs from :func:`getblame`.
    :raises NoOneToBlameWarning: If `bugs` and `blame` are given and there is one or more bugs with no blame.
    """
    # Assumption: each line can only have one author, but multiple bugs.  [Later: one language, one linetype]
    # This seems to be simpler and more efficient to do case-by-case
    if bugs and not blame:
        for bug in bugs:
            yield bug

    elif blame:
        file2line2bugs = defaultdict(lambda: defaultdict(list))
        for bug in bugs or []:
            file2line2bugs[bug.filename][bug.linenum].append(bug)

        for filename, authorlist in blame:
            linenum = 0
            for linenum, author in enumerate(authorlist[1:], 1):
                buglist = file2line2bugs.get(filename, {}).get(linenum)       # Tread lightly on defaultdicts
                if buglist:
                    for bug in buglist:
                        yield bug._replace(author=author)               # pylint: disable=W0212
                    del file2line2bugs[filename][linenum]
                else:
                    yield Analyne(filename=filename, linenum=linenum, bugtype=None, severity=None, author=author)

        # Output any remaining bugs with no blame, and raise warning.
        numbugs = 0
        for numbugs, bug in enumerate(itertools.chain.from_iterable(buglist for line2bugs in file2line2bugs.itervalues() for buglist in line2bugs.itervalues()), 1):
            yield bug
        if numbugs:
            warnings.warn(NoOneToBlameWarning(numbugs), stacklevel=2)

    else:
        return      # No inputs, no outputs.

def read_analynes(infile):
    """:Return: an iterator over :class:`Analyne` namedtuples read from open-for-reading
    text file `infile`."""
    for line in infile:
        filename, linenum, bugtype, severity, author = (field or None for field in line.rstrip('\n').split('\t'))
        linenum = int(linenum)
        severity = severity or None
        yield Analyne(filename, linenum, bugtype, severity, author)

def blame2analynes(blame):
    """:Return: an iterator over :class:`Analyne` namedtuples constructed from
    the output of :func:`getblame` `blame`."""
    for filename, authors in blame:
        for linenum, author in enumerate(authors[1:], 1):
            yield Analyne(filename, linenum, None, None, author)

def getmodule(package, module):
    """:Return: Dynamically import `module` from `package`, or `None` if it could not be imported."""
    # Is this polluting the namespace?
    return getattr(__import__(package, fromlist=[module]), module, None)     # Aren't Python imports fun?

def itergroup(iterable, isstart=lambda x: x):
    """Group `iterable` into groups starting with items where `isstart(item)` is true.

    Start items are included in the group.  The first group may or may not have
    a start item. An empty `iterable` results in an empty result (zero groups).
    """
    # Python's closures leave something to be desired
    def keyfunc(item):
        if isstart(item):
            keyfunc.groupnum += 1       # pylint: disable=E1101,W0612
        return keyfunc.groupnum         # pylint: disable=E1101
    keyfunc.groupnum = 0
    return (group for _, group in itertools.groupby(iterable, keyfunc))

class NoOneToBlameWarning(Warning):
    """Warning indicating that no attribution could be found for a bug."""
    def __init__(self, numbugs):
        """:param int numbugs: The number of bugs with no blame."""
        super(NoOneToBlameWarning, self).__init__("{0} bugs with no blame".format(numbugs))
        self.numbugs = numbugs

if set(getanalyzers()).intersection(set(getreporeaders())):
    raise ValueError("Analyzers and repo readers cannot share a name: {0}".format(set(getanalyzers()).intersection(set(getreporeaders()))))

redpajama_set_name: RedPajamaGithub


text:
package org.onosproject.net.intent.impl.phase;

import org.onosproject.net.intent.IntentData;

import static com.google.common.base.Preconditions.checkNotNull;
import static org.onosproject.net.intent.IntentState.WITHDRAWN;

/**
 * Represents a phase where an intent has been withdrawn.
 */
final class Withdrawn extends FinalIntentProcessPhase {

    private final IntentData data;

    /**
     * Create a withdrawn phase.
     *
     * @param data intent data containing an intent to be withdrawn
     */
    Withdrawn(IntentData data) {
        this.data = checkNotNull(data);
        this.data.setState(WITHDRAWN);
    }

    @Override
    public IntentData data() {
        return data;
    }
}


text:
/**
 * This is the main application file, with the express configuration
 * (We are using Express 4)
 */
'use strict';
// process.env.NODE_ENV = 'development';

var express        = require('express');
var bodyParser     = require('body-parser');
var methodOverride = require('method-override');
var app            = express();
var router         = express.Router();
var routes         = require('./routes').app;
var apiroutes      = require('./routes').api;

app.set('port', 8080);
app.set('view engine', 'jade');
/**
 * these directory configurations are needed, with these we are
 * telling express to accept the content of these directories
 */
app.use('/components', express.static(__dirname + '/components'));
app.use('/public', express.static(__dirname + '/public'));
app.use('/views', express.static(__dirname + '/views'));
app.use('/vendor', express.static(__dirname + '/vendor'));
app.use(bodyParser.urlencoded({extended: true}));
app.use(bodyParser.json({extended: true}));
app.use(methodOverride());

if (app.get('env') === 'development') {
  app.locals.pretty = true;
}

/**
 * Route configuration
 */
router.route('/').get(routes.index);
router.route('/image/:uri').get(apiroutes.imagedata);
router.route('/api/characters').get(apiroutes.characters);
router.route('/api/search/characters/:term').get(apiroutes.search);
router.route('/api/search/characters/:key/:term').get(apiroutes.search);
router.route('/api/characters/:name').get(apiroutes.character);

//route declaration for the partials
router.route('/partials/:name').get(routes.partials);

//apply routes
app.use('/', router);

app.listen(app.get('port'));
console.log('Magic happens on port ' + app.get('port'));


text:
<?php namespace Spoom\Core;

use Spoom\Core\Helper;

//
interface ConverterInterface {

  /**
   * Serialize the content to a formatted (based on the meta property) string
   *
   * @param mixed                       $content The content to serialize
   * @param Helper\StreamInterface|null $stream  Optional output stream
   *
   * @return string|null
   * @throws ConverterFailException Failed serialization
   */
  public function serialize( $content, ?Helper\StreamInterface $stream = null ): ?string;
  /**
   * Unserialize string into a php value
   *
   * @param string|Helper\StreamInterface $content The content (can be a stream) to unserialize
   *
   * @return mixed
   * @throws ConverterFailException Failed unserialization
   */
  public function unserialize( $content );

  /**
   * @return mixed
   */
  public function getMeta();
  /**
   * @param mixed $value
   *
   * @return $this
   * @throws \InvalidArgumentException Try to set a wrong Meta subclass
   */
  public function setMeta( $value );
}

//
class Converter implements ConverterInterface, Helper\AccessableInterface {
  use Helper\Accessable;

  //
  public function serialize( $content, ?Helper\StreamInterface $stream = null ):?string {

    if( ($event = new ConverterEventIO( __FUNCTION__, $this, $content, $stream ))->isPrevented() ) return $event->result;
    else {

      // modify variables from the event
      $content = $event->content;
      $stream = $event->stream;

      $result = serialize( $content );
      if( !$stream ) return $result;
      else {

        $stream->write( $result );
        return null;
      }
    }
  }
  //
  public function unserialize( $content ) {

    if( ($event = new ConverterEventIO( __FUNCTION__, $this, $content ))->isPrevented() ) return $event->result;
    else {

      // modify variables from the event
      $content = $event->content;

      // handle stream input
      if( $content instanceof Helper\StreamInterface ) {
        $content = $content->read();
      }

      return unserialize( (string) $content );
    }
  }

  //
  public function getMeta() {
    return null;
  }
  //
  public function setMeta( $_ ) {
    return $this;
  }
}

/**
 * Triggered before every Converter IO operation (serialize, unserialize), implemented in the child classes
 *
 * Prevention can skip the original IO operation. The `content` and `stream` can be modified by the callbacks
 */
class ConverterEventIO extends Event {

  const FUNCTION_SERIALIZE = 'serialize';
  const FUNCTION_UNSERIALIZE = 'unserialize';

  /**
   * @var ConverterInterface
   */
  public $instance;
  /**
   * @var string
   */
  public $function;
  /**
   * @var mixed
   */
  public $content;
  /**
   * @var ?Helper\StreamInterface
   */
  public $stream;

  /**
   * @var mixed
   */
  public $result;

  /**
   *
   */
  public function __construct( string $function, ConverterInterface $instance, $content, ?Helper\StreamInterface $stream = null ) {
    $this->function = $function;
    $this->instance = $instance;
    $this->content = $content;
    $this->stream = $stream;

    $this->trigger();
  }
}

/**
 * Failed (de-)serialization
 */
class ConverterFailException extends Exception\Runtime {

  const ID = '29#spoom-core';

  /**
   * @param ConverterInterface $instance
   * @param mixed              $content The content to (un)serialize
   * @param mixed              $error
   */
  public function __construct( ConverterInterface $instance, $content, $error = null ) {

    $data = [ 'instance' => $instance, 'content' => $content, 'error' => $error ];
    parent::__construct( '(Un)serialization failed, due to an error', static::ID, $data );
  }
}


text:
package types

import (
	"math"
)

// RoundFloat rounds float val to the nearest integer value with float64 format, like GNU rint function.
// RoundFloat uses default rounding mode, see http://www.gnu.org/software/libc/manual/html_node/Rounding.html
// so we will choose the even number if the result is midway between two representable value.
// e.g, 1.5 -> 2, 2.5 -> 2.
func RoundFloat(val float64) float64 {
	v, frac := math.Modf(val)
	if val >= 0.0 {
		if frac > 0.5 || (frac == 0.5 && uint64(v)%2 != 0) {
			v += 1.0
		}
	} else {
		if frac < -0.5 || (frac == -0.5 && uint64(v)%2 != 0) {
			v -= 1.0
		}
	}

	return v
}

func getMaxFloat(flen int, decimal int) float64 {
	intPartLen := flen - decimal
	f := math.Pow10(intPartLen)
	f -= math.Pow10(-decimal)
	return f
}

func truncateFloat(f float64, decimal int) float64 {
	pow := math.Pow10(decimal)
	t := (f - math.Floor(f)) * pow

	round := RoundFloat(t)

	f = math.Floor(f) + round/pow
	return f
}

// TruncateFloat tries to truncate f.
// If the result exceeds the max/min float that flen/decimal allowed, returns the max/min float allowed.
func TruncateFloat(f float64, flen int, decimal int) (float64, error) {
	if math.IsNaN(f) {
		// nan returns 0
		return 0, nil
	}

	maxF := getMaxFloat(flen, decimal)

	if !math.IsInf(f, 0) {
		f = truncateFloat(f, decimal)
	}

	if f > maxF {
		f = maxF
	} else if f < -maxF {
		f = -maxF
	}

	return f, nil
}


text:
title: Forestry
date: '2016-11-25 14:56:11'
layout: ''
---
This page was created with [Forestry|https://forestry.io]


text:
source /home/nbcommon/anaconda3_410/bin/activate

# Set up proxy
http_proxy=http://webproxy:3128
https_proxy=http://webproxy:3128
export http_proxy
export https_proxy

# conda
conda config --add channels conda-forge
conda install obspy -y
conda install basemap -y
conda install cartopy -y


text:
package gnu.trove;

import gnu.trove.list.TIntList;
import gnu.trove.list.array.TIntArrayList;
import gnu.trove.map.TIntObjectMap;
import gnu.trove.map.hash.TIntObjectHashMap;
import gnu.trove.set.TIntSet;
import gnu.trove.set.hash.TIntHashSet;
import junit.framework.TestCase;

/**
 *
 */
public class TCollectionsTest extends TestCase {
	public void testUnmodifiableList() {
		final TIntArrayList one = new TIntArrayList( new int[]{ 1, 2, 3, 4 } );
		final TIntArrayList two = new TIntArrayList( new int[]{ 1, 2, 3, 4 } );
		TIntList uOne = TCollections.unmodifiableList( one );
		TIntList uTwo = TCollections.unmodifiableList( two );

		assertEquals( one, two );
		assertEquals( uOne, uTwo );

	}

	public void testUnmodifiableSet() {
		final TIntSet one = new TIntHashSet( new int[]{ 1, 2, 3, 4 } );
		final TIntSet two = new TIntHashSet( new int[]{ 1, 2, 3, 4 } );
		TIntSet uOne = TCollections.unmodifiableSet( one );
		TIntSet uTwo = TCollections.unmodifiableSet( two );

		assertEquals( one, two );
		assertEquals( uOne, uTwo );
	}

	public void testUnmodifiableMap() {
		final TIntObjectMap<Integer> one = new TIntObjectHashMap<Integer>();
		one.put( 0, Integer.valueOf( 0 ) );
		one.put( 1, Integer.valueOf( 1 ) );
		one.put( 2, Integer.valueOf( 2 ) );
		one.put( 3, Integer.valueOf( 3 ) );
		final TIntObjectMap<Integer> two = new TIntObjectHashMap<Integer>( one );
		TIntObjectMap<Integer> uOne = TCollections.unmodifiableMap( one );
		TIntObjectMap<Integer> uTwo = TCollections.unmodifiableMap( two );

		assertEquals( one, two );
		assertEquals( uOne, uTwo );
	}
}


text:
<?php
/**
 * Widget API: WP_Widget_Text class
 *
 * @package WordPress
 * @subpackage Widgets
 * @since 4.4.0
 */

/**
 * Core class used to implement a Text widget.
 *
 * @since 2.8.0
 *
 * @see WP_Widget
 */
class WP_Widget_Text extends WP_Widget {

	/**
	 * Whether or not the widget has been registered yet.
	 *
	 * @since 4.8.1
	 * @var bool
	 */
	protected $registered = false;

	/**
	 * Sets up a new Text widget instance.
	 *
	 * @since 2.8.0
	 * @access public
	 */
	public function __construct() {
		$widget_ops = array(
			'classname' => 'widget_text',
			'description' => __( 'Arbitrary text.' ),
			'customize_selective_refresh' => true,
		);
		$control_ops = array(
			'width' => 400,
			'height' => 350,
		);
		parent::__construct( 'text', __( 'Text' ), $widget_ops, $control_ops );
	}

	/**
	 * Add hooks for enqueueing assets when registering all widget instances of this widget class.
	 *
	 * @param integer $number Optional. The unique order number of this widget instance
	 *                        compared to other instances of the same class. Default -1.
	 */
	public function _register_one( $number = -1 ) {
		parent::_register_one( $number );
		if ( $this->registered ) {
			return;
		}
		$this->registered = true;

		// Note that the widgets component in the customizer will also do the 'admin_print_scripts-widgets.php' action in WP_Customize_Widgets::print_scripts().
		add_action( 'admin_print_scripts-widgets.php', array( $this, 'enqueue_admin_scripts' ) );

		// Note that the widgets component in the customizer will also do the 'admin_footer-widgets.php' action in WP_Customize_Widgets::print_footer_scripts().
		add_action( 'admin_footer-widgets.php', array( $this, 'render_control_template_scripts' ) );
	}

	/**
	 * Determines whether a given instance is legacy and should bypass using TinyMCE.
	 *
	 * @since 4.8.1
	 *
	 * @param array $instance {
	 *     Instance data.
	 *
	 *     @type string      $text   Content.
	 *     @type bool|string $filter Whether autop or content filters should apply.
	 *     @type bool        $legacy Whether widget is in legacy mode.
	 * }
	 * @return bool Whether Text widget instance contains legacy data.
	 */
	public function is_legacy_instance( $instance ) {

		// Legacy mode when not in visual mode.
		if ( isset( $instance['visual'] ) ) {
			return ! $instance['visual'];
		}

		// Or, the widget has been added/updated in 4.8.0 then filter prop is 'content' and it is no longer legacy.
		if ( isset( $instance['filter'] ) && 'content' === $instance['filter'] ) {
			return false;
		}

		// If the text is empty, then nothing is preventing migration to TinyMCE.
		if ( empty( $instance['text'] ) ) {
			return false;
		}

		$wpautop = ! empty( $instance['filter'] );
		$has_line_breaks = ( false !== strpos( trim( $instance['text'] ), "\n" ) );

		// If auto-paragraphs are not enabled and there are line breaks, then ensure legacy mode.
		if ( ! $wpautop && $has_line_breaks ) {
			return true;
		}

		// If an HTML comment is present, assume legacy mode.
		if ( false !== strpos( $instance['text'], '


text:
<?php

class YamlFixtureTest extends SapphireTest {
	static $fixture_file = 'sapphire/tests/testing/YamlFixtureTest.yml';

	function testSQLInsert() {
		$object1 = DataObject::get_by_id("YamlFixtureTest_DataObject", $this->idFromFixture("YamlFixtureTest_DataObject", "testobject1"));
		$this->assertTrue($object1->ManyMany()->Count() == 2, "Should be 2 items in this manymany relationship");
		$object2 = DataObject::get_by_id("YamlFixtureTest_DataObject", $this->idFromFixture("YamlFixtureTest_DataObject", "testobject2"));
		$this->assertTrue($object2->ManyMany()->Count() == 2, "Should be 2 items in this manymany relationship");
	}
}

class YamlFixtureTest_DataObject extends DataObject {
	static $db = array(
		"Name" => "Varchar"
	);
	static $many_many = array(
		"ManyMany" => "YamlFixtureTest_DataObjectRelation"
	);
}

class YamlFixtureTest_DataObjectRelation extends DataObject {
	static $db = array(
		"Name" => "Varchar"
	);
	static $belongs_many_many = array(
		"TestParent" => "YamlFixtureTest_DataObject"
	);
}


text: export const b = () => {}


text:
package org.apache.gobblin.instrumented.extractor;

import java.io.IOException;

import org.apache.gobblin.configuration.WorkUnitState;
import org.apache.gobblin.source.extractor.DataRecordException;
import org.apache.gobblin.stream.RecordEnvelope;

/**
 * Instrumented version of {@link org.apache.gobblin.source.extractor.Extractor} automatically captures certain metrics.
 * Subclasses should implement readRecordImpl instead of readRecord.
 */
public abstract class InstrumentedExtractor<S, D> extends InstrumentedExtractorBase<S, D> {

  public InstrumentedExtractor(WorkUnitState workUnitState) {
    super(workUnitState);
  }

  /**
   * @deprecated provided for test compatibility.
   */
  @Deprecated
  @Override
  public D readRecord(@Deprecated D reuse) throws DataRecordException, IOException {
    return this.readRecordImpl(null);
  }

  @Override
  public final RecordEnvelope<D> readRecordEnvelope()
      throws DataRecordException, IOException {
    return super.readRecordEnvelope();
  }
}


text:
<?php

declare(strict_types=1);

namespace Windwalker\Database\Driver\Pgsql;

use Windwalker\Database\Driver\AbstractDriver;
use Windwalker\Database\Driver\StatementInterface;
use Windwalker\Database\Platform\PostgreSQLPlatform;

/**
 * The PgsqlDriver class.
 */
class PgsqlDriver extends AbstractDriver
{
    /**
     * @var string
     */
    protected static $name = 'pgsql';

    /**
     * @var string
     */
    protected $platformName = 'pgsql';

    /**
     * @inheritDoc
     */
    public function doPrepare(string $query, array $bounded = [], array $options = []): StatementInterface
    {
        $conn = $this->connect()->get();

        return new PgsqlStatement($conn, $query, $bounded);
    }

    /**
     * @inheritDoc
     */
    public function lastInsertId(?string $sequence = null): ?string
    {
        /** @var PostgreSQLPlatform $platform */
        $platform = $this->getPlatform();

        return $platform->lastInsertId($this->lastQuery, $sequence);
    }

    /**
     * @inheritDoc
     */
    public function quote(string $value): string
    {
        return "'" . $this->escape($value) . "'";
    }

    /**
     * @inheritDoc
     */
    public function escape(string $value): string
    {
        return pg_escape_string($this->connect()->get(), $value);
    }

    /**
     * getVersion
     *
     * @return  string
     */
    public function getVersion(): string
    {
        return pg_version($this->connect()->get())['server'] ?? '';
    }
}


text:
/*
 * WildFire.cpp
 *
 * This is for wildfire occurrence and C/N pool dynamics due to fire
 *   (1) Fire occurrence either by input or FRI derived
 *   (2) Fire severity either by ALFRESCO input, or determined by
 *         'size','season' and 'landscape position'
 *
 *   (3) C/N pools updated here through operation on 'bd' -
 *         NOTE this 'bd' is for all PFTs and soil.
 *         this is to say, individual PFT's C/N pools updating need to
 *         do elsewhere
 *
 *   (4) ROOTFRAC is updated here through operation on 'ed' - also for ALL PFTS.
 *
 *   (5) soil layer structure is NOT changed here, but will re-do in
 *         Ground::adjustSoilAfterBurn()
 *
 *   (6) NOTE: assuming ONE root pool, and its index is 'NUM_PFT_PART'
 *         (i.e. the last).
 *
 */

#include <string>
#include <sstream>

#include "WildFire.h"

#include "../TEMUtilityFunctions.h"
#include "../TEMLogger.h"

extern src::severity_logger< severity_level > glg;

WildFire::WildFire() {}

WildFire::~WildFire() {}

WildFire::WildFire(const std::string& fri_fname,
                   const std::string& explicit_fname, const int y, const int x) {

  BOOST_LOG_SEV(glg, info) << "Setting up FRI fire data...";
  this->fri = temutil::get_scalar<int>(fri_fname, "fri", y, x);
  this->fri_severity = temutil::get_scalar<int>(fri_fname, "fri_severity", y, x);
  this->fri_day_of_burn = temutil::get_scalar<int>(fri_fname, "fri_day_of_burn", y, x);

  BOOST_LOG_SEV(glg, info) << "Setting up explicit fire data...";
  this->explicit_fire_year = temutil::get_timeseries<int>(explicit_fname, "explicit_fire_year", y, x);
  this->explicit_fire_severity = temutil::get_timeseries<int>(explicit_fname, "explicit_fire_severity", y, x);
  this->explicit_fire_day_of_burn = temutil::get_timeseries<int>(explicit_fname, "explicit_fire_day_of_burn", y, x);

  // Set to an definitely invalid number.
  // Later this will be set to a valid number based on the run stage and
  // possibly other factors.
  this->actual_severity = -1;

  // need templates or more overloads or something so that we can
  // read the std::vector<int>
  //fire_years = temutil::get_timeseries(fname, "fire_years", y, x);
  //fire_sizes = temutil::get_timeseries<float>(fname, "fire_sizes", y, x);
  //fire_month = temutil::get_timeseries(fname, "fire_month", y, x);

  BOOST_LOG_SEV(glg, debug) << "Done making WildFire object.";
  BOOST_LOG_SEV(glg, debug) << this->report_fire_inputs();

}

/** Assemble and return a string with a bunch of data from this class */
std::string WildFire::report_fire_inputs() {

  std::stringstream report_string;
  report_string << "FRI based fire vectors/data:" << std::endl;
  report_string << "FRI:              " << this->fri << std::endl;
  report_string << "FRI day_of_burn:  " << this->fri_day_of_burn << std::endl;
  report_string << "FRI severity:     " << this->fri_severity << std::endl;
  report_string << "Explicit fire vectors/data:" << std::endl;
  report_string << "explicit fire year:        [" << temutil::vec2csv(this->explicit_fire_year) << "]" << std::endl;
  report_string << "explicit fire day_of_burn: [" << temutil::vec2csv(this->explicit_fire_day_of_burn) << "]" << std::endl;
  report_string << "explicit fire severity:    [" << temutil::vec2csv(this->explicit_fire_severity) << "]" << std::endl;

  report_string << "Actual Fire Severity: " << this->actual_severity << std::endl;

  return report_string.str();

}

// Looks like this is just used when setting up a Cohort...
void WildFire::initializeParameter() {
  for (int i=0; i<NUM_FSEVR; i++) {
    for (int ip=0; ip<NUM_PFT; ip++) {
      firpar.fvcomb[i][ip] = chtlu->fvcombust[i][ip];
      firpar.fvdead[i][ip] = chtlu->fvslash[i][ip];
    }

    firpar.foslburn[i] = chtlu->foslburn[i];
  }

  firpar.vsmburn = chtlu->vsmburn; // a threshold value of VWC for burn
                                   //   organic layers
  firpar.r_retain_c = chtlu->r_retain_c;
  firpar.r_retain_n = chtlu->r_retain_n;
};

void WildFire::initializeState() {
  fd->fire_a2soi.orgn = 0.0;
};

// Looks like this is just used when setting up a Cohort from a Restart file...
void WildFire::set_state_from_restartdata(const RestartData & rdata) {
  fd->fire_a2soi.orgn = rdata.firea2sorgn;
}

/** Returns an integer in closed range 0-4 represening fire severity.
*  Finds fire severity as a function of drainage (well or poor) season (1-4)
*  and size (??range?).
*/
int WildFire::derive_fire_severity(const int drainage, const int day_of_burn, const int size) {

  // This function/way of thinking may become obsolete!
  //  - short term: read severity as an input
  //  - longer term: do away with severity classification and calculate
  //    % of organic layer to combust based on the following arguments:
  //    (stage, slope, aspect, drainage, doy, aob, roab, tshlw)

  assert ( (drainage == 0 || drainage == 1) && "Invalid drainage!");
  assert ( (day_of_burn <= 364 && day_of_burn >= 0) && "Invalid day of burn!");
  assert ( (size  && size >= 0) && "Invalid fire size!");

  int severity;

  if (drainage == 1) {
    severity = 0; // poorly drained, can't burn wet ground
  }

  if( drainage == 0 ) {  // well drained

    BOOST_LOG_SEV(glg, err) << "NOT IMPLEMENTED YET...";
    // NEED A WAY TO PARTITION BASED ON SIZE AND DAY OF YEAR?

  }

  return severity;
}

/** Figure out whether or not there should be a fire, based on stage, yr, month.
 *
 *  There are two modes of operation: "FRI" (fire recurrence interval) and
 *  "explicit". Pre-run, equilibrium, and spin-up stages all use the FRI settings
 *  for determining whether or not a fire should ignite, while transient and
 *  scenario stages use explicit dates for fire occurrence.
 *
 *  The settings for FRI and the data for explicit fire dates are held in data
 *  members of this (WildFire) object. This function looks at those data
 *  and sets the "actual_severity" member accordingly.
 *
*/
bool WildFire::should_ignite(const int yr, const int midx, const std::string& stage) {

  BOOST_LOG_SEV(glg, note) << "determining fire ignition for yr:" << yr
                           << ", monthidx:" << midx << ", stage:" << stage;

  bool ignite = false;

  if ( stage.compare("pre-run") == 0 || stage.compare("eq-run") == 0 || stage.compare("sp-run") == 0 ) {

    BOOST_LOG_SEV(glg, debug) << "Determine fire by FRI.";

    if ( (yr % this->fri) == 0 && yr > 0 ) {
      if (midx == temutil::doy2month(this->fri_day_of_burn)) {
        ignite = true;
        this->actual_severity = this->fri_severity;
      }
      // do nothing: correct year, wrong month.
    }

  } else if ( stage.compare("tr-run") == 0 || stage.compare("sc-run") == 0 ) {

    BOOST_LOG_SEV(glg, debug) << "Determine fire by explicit year.";

    if ( this->explicit_fire_year[yr] == 1 ){
      if ( temutil::doy2month(this->explicit_fire_day_of_burn[yr]) == midx ) {
        ignite = true;
        this->actual_severity = this->explicit_fire_severity.at(yr);
      }
      // do nothing: correct year, wrong month
    }
  } else {
    BOOST_LOG_SEV(glg, err) << "Unknown stage! (" << stage << ")";
  }

  BOOST_LOG_SEV(glg, debug) << "Should we ignite a fire?:" << ignite;

  return ignite;
}

/** Burning vegetation and soil organic C */
void WildFire::burn(int year) {
  BOOST_LOG_NAMED_SCOPE("burning");
  BOOST_LOG_SEV(glg, note) << "HELP!! - WILD FIRE!! RUN FOR YOUR LIFE!";

  assert ((this->actual_severity >= 0) && (this->actual_severity < 5) && "Invalid fire severity!");
  BOOST_LOG_SEV(glg, debug) << "Fire severity: " << this->actual_severity;

  BOOST_LOG_SEV(glg, debug) << fd->report_to_string("Before WildFire::burn(..)");
  BOOST_LOG_SEV(glg, note) << "Burning (simply clearing?) the 'FireData object...";
  fd->burn();
  BOOST_LOG_SEV(glg, debug) << fd->report_to_string("After FirData::burn(..)");

  // for soil part and root burning
  // FIX: there isn't really a reason for getBurnOrgSoilthick to return a value
  // as it has already set the "burn thickness" value in FirData...
  double burndepth = getBurnOrgSoilthick(this->actual_severity);
  BOOST_LOG_SEV(glg, debug) << fd->report_to_string("After WildFire::getBurnOrgSoilthick(..)");

  BOOST_LOG_SEV(glg, note) << "Setup some temporary pools for tracking various burn related attributes (depths, C, N)";
  double totbotdepth = 0.0;
  double burnedsolc = 0.0;
  double burnedsoln = 0.0;
  double r_burn2bg_cn[NUM_PFT]; // ratio of dead veg. after burning
  for (int ip=0; ip<NUM_PFT; ip++) {
    r_burn2bg_cn[ip] = 0.; //  used for vegetation below-ground (root) loss,
                           //  and calculated below
  }

  BOOST_LOG_SEV(glg, debug) << "Handle burning the soil (loop over all soil layers)...";
  for (int il = 0; il < cd->m_soil.numsl; il++) {

    BOOST_LOG_SEV(glg, debug) << "== Layer Info == "
                              << "   type:" << cd->m_soil.type[il] // 0:moss 1:shlwpeat 2:deeppeat 3:mineral
                              << "   dz:" << cd->m_soil.dz[il]
                              << "   top:" << cd->m_soil.z[il]
                              << "   bottom:"<< cd->m_soil.z[il] + cd->m_soil.dz[il];

    if(cd->m_soil.type[il] <= 2) {

      totbotdepth += cd->m_soil.dz[il];

      double ilsolc =  bdall->m_sois.rawc[il] + bdall->m_sois.soma[il] +
                       bdall->m_sois.sompr[il] + bdall->m_sois.somcr[il];

      double ilsoln =  bdall->m_sois.orgn[il] + bdall->m_sois.avln[il];

      if(totbotdepth <= burndepth) { //remove all the orgc/n in this layer
        BOOST_LOG_SEV(glg, debug) << "Haven't reached burndepth (" << burndepth << ") yet. Remove all org C and N in this layer";
        burnedsolc += ilsolc;
        burnedsoln += ilsoln;
        bdall->m_sois.rawc[il] = 0.0;
        bdall->m_sois.soma[il] = 0.0;
        bdall->m_sois.sompr[il]= 0.0;
        bdall->m_sois.somcr[il]= 0.0;
        bdall->m_sois.orgn[il] = 0.0;
        bdall->m_sois.avln[il] = 0.0;

        for (int ip=0; ip<NUM_PFT; ip++) {
          if (cd->m_veg.vegcov[ip]>0.) {
            r_burn2bg_cn[ip] += cd->m_soil.frootfrac[il][ip];
            cd->m_soil.frootfrac[il][ip] = 0.0;
          }
        }
      } else {
        BOOST_LOG_SEV(glg, debug) << "The bottom of this layer (il: " << il << ") is past the 'burndepth'. Find the remaining C and N as a fraction of layer thickness";
        double partleft = totbotdepth - burndepth;

        // Calculate the remaining C, N
        if(partleft < cd->m_soil.dz[il]) { // <-- Maybe this should be an assert instead of an if statement??
          BOOST_LOG_SEV(glg, debug) << "Burning all but "<<partleft<<"of layer "<<il;
          burnedsolc += (1.0-partleft/cd->m_soil.dz[il]) * ilsolc;
          burnedsoln += (1.0-partleft/cd->m_soil.dz[il]) * ilsoln;
          bdall->m_sois.rawc[il] *= partleft/cd->m_soil.dz[il];
          bdall->m_sois.soma[il] *= partleft/cd->m_soil.dz[il];
          bdall->m_sois.sompr[il] *= partleft/cd->m_soil.dz[il];
          bdall->m_sois.somcr[il] *= partleft/cd->m_soil.dz[il];
          bdall->m_sois.orgn[il] *= partleft/cd->m_soil.dz[il];
          bdall->m_sois.avln[il] *= partleft/cd->m_soil.dz[il];

          for (int ip=0; ip<NUM_PFT; ip++) {
            if (cd->m_veg.vegcov[ip] > 0.0) {
              r_burn2bg_cn[ip] += (1-partleft/cd->m_soil.dz[il])
                                * cd->m_soil.frootfrac[il][ip];
              cd->m_soil.frootfrac[il][ip] *= partleft/cd->m_soil.dz[il];
            }
          }
        } else {
          // should never get here??
          BOOST_LOG_SEV(glg, err) << "The remaining soil after a burn is greater than the thickness of this layer. Something is wrong??";
          BOOST_LOG_SEV(glg, err) << "partleft: " << partleft << "cd->m_soil.dz["<<il<<"]: " << cd->m_soil.dz[il];
          break;
        }
      }
    } else {   //Mineral soil layers
      BOOST_LOG_SEV(glg, note) << "Layer type:" << cd->m_soil.type[il] << ". Should be a non-organic soil layer? (greater than type 2)";

      BOOST_LOG_SEV(glg, note) << "Not much to do here. Can't really burn non-organic layers.";

      if(totbotdepth <= burndepth) { //may not be needed, but just in case
        BOOST_LOG_SEV(glg, note) << "For some reason totbotdepth <= burndepth, so we are setting fd->fire_soid.burnthick = totbotdepth??";
        fd->fire_soid.burnthick = totbotdepth;
      }

    }
  } // end soil layer loop

  //Setting relative organic layer burn (rolb) value
  fd->fire_soid.rolb = fd->fire_soid.burnthick / totbotdepth;

  // needs to re-do the soil rootfrac for each pft which was modified above
  //   (in burn soil layer)
  BOOST_LOG_SEV(glg, note) << "Re-do the soil root fraction for each PFT modified by burning?";
  for (int ip = 0; ip < NUM_PFT; ip++) {
    double rootfracsum = 0.0;

    for (int il = 0; il < cd->m_soil.numsl; il++) {
      rootfracsum += cd->m_soil.frootfrac[il][ip];
    }

    for (int il =0; il <cd->m_soil.numsl; il++) {
      cd->m_soil.frootfrac[il][ip] /= rootfracsum;
    }
  }

  // all woody debris will burn out
  BOOST_LOG_SEV(glg, note) << "Handle burnt woody debris...";
  double wdebrisc = bdall->m_sois.wdebrisc; //
  double wdebrisn = bdall->m_sois.wdebrisn; //
  bdall->m_sois.wdebrisc = 0.0;
  bdall->m_sois.wdebrisn = 0.0;

  // summarize
  BOOST_LOG_SEV(glg, note) << "Summarize...?";
  double vola_solc = (burnedsolc + wdebrisc) * (1.0 - firpar.r_retain_c);
  double vola_soln = (burnedsoln + wdebrisn) * (1.0 - firpar.r_retain_n);
  double reta_solc = burnedsolc * firpar.r_retain_c;   //together with veg.-burned N return, This will be put into soil later
  double reta_soln = burnedsoln * firpar.r_retain_n;   //together with veg.-burned N return, This will be put into soil later

  BOOST_LOG_SEV(glg, note) << "Handle Vegetation burning and mortality...";
  double comb_vegc = 0.0;  // summed for all PFTs
  double comb_vegn = 0.0;
  double comb_deadc = 0.0;
  double comb_deadn = 0.0;
  double dead_bg_vegc = 0.0;
  double dead_bg_vegn = 0.0;
  double veg_2_dead_C = 0.0;
  double veg_2_dead_N = 0.0;

  bdall->m_vegs.deadc0 = 0;//Zeroing the standing dead pools
  bdall->m_vegs.deadn0 = 0;

  for (int ip = 0; ip < NUM_PFT; ip++) {

    if (cd->m_veg.vegcov[ip] > 0.0) {
      BOOST_LOG_SEV(glg, note) << "Some of PFT"<<ip<<" exists (coverage > 0). Burn it!";

      // vegetation burning/dead/living fraction for above-ground
      getBurnAbgVegetation(ip, this->actual_severity);

      // root death ratio: must be called after both above-ground and
      // below-ground burning. r_live_cn is same for both above-ground
      // and below-ground
      double r_dead2bg_cn = 1.0-r_burn2bg_cn[ip]- r_live_cn;

      // Dead veg C, N. Assuming all previous deadc burned.
      comb_deadc += bd[ip]->m_vegs.deadc;

      // Assuming all previous deadn burned
      comb_deadn += bd[ip]->m_vegs.deadn;
      //Zeroing the standing dead pools
      bd[ip]->m_vegs.deadc0 = 0.0;
      bd[ip]->m_vegs.deadn0 = 0.0;

      veg_2_dead_C = (bd[ip]->m_vegs.c[I_leaf] + bd[ip]->m_vegs.c[I_stem]) * r_dead2ag_cn;
      veg_2_dead_N = (bd[ip]->m_vegs.strn[I_leaf] + bd[ip]->m_vegs.strn[I_stem]) * r_dead2ag_cn;

      // Above-ground veg. burning/death during fire
      // when summing, needs adjusting by 'vegcov'
      comb_vegc += bd[ip]->m_vegs.c[I_leaf] * r_burn2ag_cn;

      // We define dead c/n as the not-falling veg (or binding with living veg)
      // during fire,
      bd[ip]->m_vegs.deadc = bd[ip]->m_vegs.c[I_leaf] * r_dead2ag_cn;
      // Which then is the source of ground debris (this is for woody plants
      // only, others could be set deadc/n to zero)
      bd[ip]->m_vegs.c[I_leaf] *= (1.0 - r_burn2ag_cn - r_dead2ag_cn);

      comb_vegc += bd[ip]->m_vegs.c[I_stem] * r_burn2ag_cn;
      bd[ip]->m_vegs.deadc += bd[ip]->m_vegs.c[I_stem] * r_dead2ag_cn;
      bd[ip]->m_vegs.c[I_stem] *= (1.0 - r_burn2ag_cn-r_dead2ag_cn);

      comb_vegn += bd[ip]->m_vegs.strn[I_leaf] * r_burn2ag_cn;
      bd[ip]->m_vegs.deadn += bd[ip]->m_vegs.strn[I_leaf] * r_dead2ag_cn;
      bd[ip]->m_vegs.strn[I_leaf] *= (1.0 - r_burn2ag_cn-r_dead2ag_cn);

      comb_vegn += bd[ip]->m_vegs.strn[I_stem] * r_burn2ag_cn;
      bd[ip]->m_vegs.deadn += bd[ip]->m_vegs.strn[I_stem] * r_dead2ag_cn;
      bd[ip]->m_vegs.strn[I_stem] *= (1.0 - r_burn2ag_cn - r_dead2ag_cn);

      // Below-ground veg. (root) burning/death during fire
      comb_vegc += bd[ip]->m_vegs.c[I_root] * r_burn2bg_cn[ip];
      comb_vegn += bd[ip]->m_vegs.strn[I_root] * r_burn2bg_cn[ip];

      // For the dead below-ground C caused by fire, they are put into original layer
      double deadc_tmp = bd[ip]->m_vegs.c[I_root]*r_dead2bg_cn;
      for (int il = 0; il < cd->m_soil.numsl; il++) {
        if (cd->m_soil.frootfrac[il][ip] > 0.0) {
          //for this, 'rootfrac' must be updated above
          bdall->m_sois.somcr[il] += deadc_tmp * cd->m_soil.frootfrac[il][ip];
        }
      }
      dead_bg_vegc += deadc_tmp;
      bd[ip]->m_vegs.c[I_root] *= (1.0 - r_burn2bg_cn[ip] - r_dead2bg_cn);

      // For the dead below-ground N caused by fire, they are put into original layer
      double deadn_tmp = bd[ip]->m_vegs.strn[I_root] * r_dead2bg_cn; //this is needed below
      for (int il =0; il <cd->m_soil.numsl; il++) {
        if (cd->m_soil.frootfrac[il][ip] > 0.0) {
          //for this, 'rootfrac' must be updated above
          bdall->m_sois.somcr[il] += deadn_tmp*cd->m_soil.frootfrac[il][ip];
        }
      }
      dead_bg_vegn +=deadn_tmp;
      bd[ip]->m_vegs.strn[I_root] *= (1.0 - r_burn2bg_cn[ip] - r_dead2bg_cn);

      // one more veg N pool (labile N)
      comb_vegn += bd[ip]->m_vegs.labn * (1.0 - r_live_cn);//assuming all labn emitted, leaving none into deadn
      bd[ip]->m_vegs.labn *= r_live_cn;

      // finally, we have:
      bd[ip]->m_vegs.call = bd[ip]->m_vegs.c[I_leaf]
                            + bd[ip]->m_vegs.c[I_stem]
                            + bd[ip]->m_vegs.c[I_root];
      bd[ip]->m_vegs.nall = bd[ip]->m_vegs.strn[I_leaf]
                            + bd[ip]->m_vegs.strn[I_stem]
                            + bd[ip]->m_vegs.strn[I_root]
                            + bd[ip]->m_vegs.labn;

    } // end of 'cd->m_veg.vegcov[ip] > 0.0' (no coverage, nothing to do)

    //Writing out initial standing dead pools. These values will be
    //used to compute the rate of decomposition of the standing dead -
    //1/9th of the original value per year.
    bd[ip]->m_vegs.deadc0 = veg_2_dead_C;
    bd[ip]->m_vegs.deadn0 = veg_2_dead_N;

    //Writing out initial values of standing dead pools to the pools
    //actually used for computation. These values will be decremented
    //by 1/9th the original value per year.
    bd[ip]->m_vegs.deadc = veg_2_dead_C;
    bd[ip]->m_vegs.deadn = veg_2_dead_N;

  } // end pft loop

  double reta_vegc = (comb_vegc + comb_deadc) * firpar.r_retain_c;
  double reta_vegn = (comb_vegn + comb_deadn) * firpar.r_retain_n;

  //Writing out initial standing dead pools. These values will be
  //used to compute the rate of decomposition of the standing dead -
  //1/9th of the original value per year.
  //bdall->m_vegs.deadc0 = veg_2_dead_C;
  //bdall->m_vegs.deadn0 = veg_2_dead_N;

  //Writing out initial values of standing dead pools to the pools
  //actually used for computation. These values will be decremented
  //by 1/9th the original value per year.
  //bdall->m_vegs.deadc = veg_2_dead_C;
  //bdall->m_vegs.deadn = veg_2_dead_N;

  BOOST_LOG_SEV(glg, note) << "Save the fire emission and return data into 'fd'...";
  //Summing the PFT specific fluxes to dead standing
  for(int ip=0; ip<NUM_PFT; ip++){
    fd->fire_v2dead.vegC += bd[ip]->m_vegs.deadc;
    fd->fire_v2dead.strN += bd[ip]->m_vegs.deadn;
  }
  //fd->fire_v2dead.vegC = veg_2_dead_C;
  //fd->fire_v2dead.strN = veg_2_dead_N;
  fd->fire_v2a.orgc =  comb_vegc - reta_vegc;
  fd->fire_v2a.orgn =  comb_vegn - reta_vegn;
  fd->fire_v2soi.abvc = reta_vegc;
  fd->fire_v2soi.abvn = reta_vegn;
  fd->fire_v2soi.blwc = dead_bg_vegc;
  fd->fire_v2soi.blwn = dead_bg_vegn;
  fd->fire_soi2a.orgc = vola_solc;
  fd->fire_soi2a.orgn = vola_soln;

  // the above 'v2a.orgn' and 'soi2a.orgn', will be as one of N source,
  // which is depositing into soil evenly in one FRI
  //- this will let the system -N balanced in a long-term, if NO
  //  open-N cycle included
  //This should occur every month post-fire. FIX
  fd->fire_a2soi.orgn = (fd->fire_soi2a.orgn + fd->fire_v2a.orgn) / this->fri;

  //put the retained C/N into the first unburned soil layer's
  //  chemically-resistant SOMC pool
  // Note - this 'retained C' could be used as char-coal, if need to do so.
  //        Then define the 'r_retain_c' in the model shall be workable
  for (int il = 0; il < cd->m_soil.numsl; il++) {
    double tsomc = bdall->m_sois.rawc[il] + bdall->m_sois.soma[il]
                   + bdall->m_sois.sompr[il] + bdall->m_sois.somcr[il];

    if(tsomc > 0. || il==cd->m_soil.numsl-1) {
      // this may possibly put retac/n in the first mineral soil
      bdall->m_sois.somcr[il] += reta_vegc + reta_solc;
      bdall->m_sois.orgn[il]  += reta_vegn + reta_soln;
      break;
    }
  }

  //Need to copy 'bdall->m_soils' to other PFTs, because above
  //  soil portion of 'bd' is done on 'bdall'
  for (int ip=1; ip<NUM_PFT; ip++) {
    if (cd->m_veg.vegcov[ip]>0.) {
      bd[ip]->m_sois = bdall->m_sois;
    }
  }
};

// above ground burning ONLY, based on fire severity indirectly or directly
void WildFire::getBurnAbgVegetation(const int &ip, const int severity) {
  assert ((severity >= 0 && severity <5) && "Invalid fire severity!!");

  BOOST_LOG_SEV(glg, note) << "Lookup the above ground vegetation burned as a funciton of severity.";
  BOOST_LOG_SEV(glg, note) << " - Set the ratios for 'burn to above ground C,N' and 'dead to above ground C,N' member variables.";
  BOOST_LOG_SEV(glg, note) << " - Set the 'ratio live cn' member variable";

  // Yuan: the severity categories are from ALFRESCO:
  // 0 - no burning
  // 1 - low
  // 2 - moderate
  // 3 - high + low surface
  // 4 - high + high surface

  this->r_burn2ag_cn = firpar.fvcomb[severity][ip];
  this->r_dead2ag_cn = firpar.fvdead[severity][ip];

  this->r_live_cn = 1.0 - r_burn2ag_cn - r_dead2ag_cn;
}

/** Returns the fraction of the organic soil layer to burn based on a variety of
    factors.
*/
double burn_organic_soil(const int aob, const int dob /* slope, aspect, soil temp, etc? */) {
  // ??
}

/** Find the thickness of organic soil to burn.
* Use severity (lookup? or derive?) and soil moisture prpoperties
* (volumetric soil moisture).
* Three rules:
*   1. only organic layer can be burned
*   2. can't exceed a pixel specified 'max burn thickness'
*   3. should not burn into "wet" organic soil layers
*/
double WildFire::getBurnOrgSoilthick(const int severity) {
  BOOST_LOG_SEV(glg, info) << "Find the amount of organic soil that is burned as a function of fire severity.";
  assert((0 <= severity && severity < 5) && "Invalid fire severity! ");

  double burn_thickness = 0.0;

  //  For now, severity class is based on ALFRESCO:
  //  0 - no burning
  //  1 - low
  //  2 - moderate
  //  3 - high + low surface
  //  4 = high + high surface

  double total_organic_thickness =  cd->m_soil.mossthick
                                    + cd->m_soil.shlwthick
                                    + cd->m_soil.deepthick ;

  BOOST_LOG_SEV(glg, debug) << "Total organic thickness: " << total_organic_thickness;

  //  Lookup burn thickness, based on severity and
  //  'fraction organic soil layer burned' parameter.
  //  (foslburn ==> "fraction organic soil layer burned")
  burn_thickness = firpar.foslburn[severity] * total_organic_thickness;
  BOOST_LOG_SEV(glg, debug) << "Calc burn thickness (severity): " << burn_thickness;

  //  VSM constrained burn thickness
  //  Find all layers where there is not much volumentric water - infact, less
  //  water than specified in the fire parameters for 'vmsburn'
  double total_dry_organic_thickness = 0.0;

  for (int i = 0; i < cd->m_soil.numsl; i++) {
    // 0:moss, 1:shlw peat, 2:deep peat, 3:mineral
    if( cd->m_soil.type[i] <= 2 ) {

      if (edall->m_soid.vwc[i] <= (firpar.vsmburn * cd->m_soil.por[i]) ) {
        total_dry_organic_thickness += cd->m_soil.dz[i];
      }
      // layer is too wet to burn
      // will all layers below this be too wet?
      // should we break the layer loop here?

    } else {
      break; // can't burn mineral soil
    }
  }
  if ( burn_thickness > total_dry_organic_thickness ) {
    burn_thickness = total_dry_organic_thickness;
    BOOST_LOG_SEV(glg, debug) << "Whoops! Burn thickness was greater than the thicknes of dry organic material. Constraining burn thickness...";
  }
  BOOST_LOG_SEV(glg, debug) << "Calculated burn thickness using VSM constraint: " << burn_thickness;

  // always burn all moss, even if the severity is really low.
  if( burn_thickness < cd->m_soil.mossthick ) {
    BOOST_LOG_SEV(glg, debug) << "Whoops! Shallow burn, but we always burn all the moss!.";
    burn_thickness = cd->m_soil.mossthick;   //burn all moss layers
  }

  // Not sure that this will work in all circumstances?
  //// there are at least 2 cm orgnanic left
  //if( (total_dry_organic_thickness - burn_thickness) < 0.02 ){
  //  BOOST_LOG_SEV(glg, debug) << "Whoops! Can't burn everything. Always leave a few cm of organic material.";
  //  burn_thickness = total_dry_organic_thickness - 0.02;
  //}

  BOOST_LOG_SEV(glg, debug) << "Setting the burn thickness in FirData...";
  fd->fire_soid.burnthick = burn_thickness;

  BOOST_LOG_SEV(glg, info) << "Final Calculated Organic Burn Thickness: " << burn_thickness;
  return burn_thickness;
};

void WildFire::setCohortLookup(CohortLookup* chtlup) {
  chtlu = chtlup;
};

void WildFire::setCohortData(CohortData* cdp) {
  cd = cdp;
};

void WildFire::setAllEnvBgcData(EnvData* edp, BgcData *bdp) {
  edall = edp;
  bdall = bdp;
};

void WildFire::setBgcData(BgcData* bdp, const int &ip) {
  bd[ip] = bdp;
};

void WildFire::setFirData(FirData* fdp) {
  fd =fdp;
}

int WildFire::getFRI(){
  return fri;
}


text:
<?php
  $page_title = 'Participantes en evento';
  $page = 'event';
  include("templates/header.php");
?>

Lista de participantes del torneo

          <input type="text" id="edit-query" name="query" value="" size="30" maxlength="128" class="search-form__text" placeholder="Buscar...">

Listado de Participantes

            Categoría
            Género
            Nombre
            Victorias
            Derrotas

  <?php
    include("templates/footer.php");
  ?>


text:
require 'oga'

module Dryrun

  class ManifestParser

    attr_accessor :package, :launcher_activity

    def initialize(manifest_file)
      doc = Oga.parse_xml(manifest_file)

      @package = get_package(doc)
      @launcher_activity = get_launcher_activity(doc)
    end

    def get_package(doc)
      doc.xpath('//manifest').attr('package').first.value
    end

    def get_launcher_activity(doc)
      activities = doc.css('activity')
      activities.each do |child|
        intent_filter = child.css('intent-filter')

        if !intent_filter.nil? && !intent_filter.empty?
          return child.attr('android:name').value
        end
      end
      false
    end

  end
end


text:
{
    "title" : "How do I Convert a Microsoft Excel Spreadsheet to a HTML?  "
}

How do I Convert a Microsoft Excel Spreadsheet to a HTML?
==

It is very simple to convert a Microsoft Excel Spreadsheet to a HTML file  on the command line using [Docto](https://github.com/tobya/docto). You can also do this easily in Microsoft Excel, but sometimes it helps to be able to do it from the command line.

The command line below shows how you can convert a Microsoft Excel Spreadsheet Document to a HTML File file - HTML.

Command Line
-

 ````
 docto -XL -f 'c:\path\Spreadsheet.xls' -o 'c:\path\Spreadsheet.HTML' -t xlHtml
 ````

 or easier to read

  ````
 docto -XL  -f 'c:\path\Spreadsheet.xls'
            -o 'c:\path\Spreadsheet.HTML'
            -t xlHtml
 ````

Command Line Explained
-

 - `-XL`   This is a conversion using Microsoft Excel.
 - `-f`   The File or directory to be converted
 - `-o`   The Output File or Directory where you would like the converted file to be written to.
 - `-T`   The file format type that is being converted to

Some other interesting commands
-

You might find some of the following commands also interesting.

Other File Types Available for Conversion
-

The following values below can be used to convert a Microsoft Excel Spreadsheet to another file type.

````
xlAddIn=18
xlCSV=6
xlCSVMac=22
xlCSVMSDOS=24
xlCSVWindows=23
xlCurrentPlatformText=-4158
xlDBF2=7
xlDBF3=8
xlDBF4=11
xlDIF=9
xlExcel12=50
xlExcel2=16
xlExcel2FarEast=27
xlExcel3=29
xlExcel4=33
xlExcel4Workbook=35
xlExcel5=39
xlExcel7=39
xlExcel8=56
xlExcel9795=43
xlHtml=44
xlIntlAddIn=26
xlIntlMacro=25
xlOpenDocumentSpreadsheet=60
xlOpenXMLAddIn=55
xlOpenXMLTemplate=54
xlOpenXMLTemplateMacroEnabled=53
xlOpenXMLWorkbook=51
xlOpenXMLWorkbookMacroEnabled=52
xlSYLK=2
xlTemplate=17
xlTextMac=19
xlTextMSDOS=21
xlTextPrinter=36
xlTextWindows=20
xlUnicodeText=42
xlWebArchive=45
xlWJ2WD1=14
xlWJ3=40
xlWJ3FJ3=41
xlWK1=5
xlWK1ALL=31
xlWK1FMT=30
xlWK3=15
xlWK3FM3=32
xlWK4=38
xlWKS=4
xlWorkbookDefault=51
xlWorkbookNormal=-4143
xlWorks2FarEast=28
xlWQ1=34
xlXMLSpreadsheet=46
xlTypePDF=50000
xlpdf=50000
xlTypeXPS=50001
xlXPS=50001

````


text:
FFI bindings to correngine.

[Documentation](https://retep998.github.io/doc/correngine-sys/)


text:
package bravo.game.manager;

import java.util.Random;

import org.opencv.samples.colorblobdetect.MarkerDetector;

import com.MobileAnarchy.Android.Widgets.Joystick.JoystickView;
import com.example.bravo.MainActivity;
import com.example.bravo.R;

import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.util.Log;
import android.widget.TextView;
import bravo.game.manager.roboRebe;

public class GameManager {
	public static final int     NUM_OF_TOWERS = 6;
	private MainActivity mMainActivity;
	private TextView mTextDebug; //TopLeft
	private TextView mTextTimeStemp; //TopRight
	private TextView mTextBottomRight; //BottomRight
	private TextView mTextBravoVersion;
	private TextView mTextMiddle; //Middle
	private int mCoinDistribution, mNumOfTowers, mLazerDistribution;
	private Random mRandomGenerator;
	private boolean flagForDebug, gameStarted;
	enum direction {keepGO, stop, front, back};
	private boolean towerHitFlag = false;
	private boolean laserHitFlag = false;
	private roboRebe myRobotGameplay;

	private GameTimer mGameTimer;

	private static final String TAG = "gameMen";

	public GameManager(MainActivity activity) {
		gameStarted = false;
		mNumOfTowers = NUM_OF_TOWERS;
		mMainActivity = activity;
		mTextDebug = (TextView) mMainActivity.findViewById(R.id.ScoreTopRight);
		mTextDebug.setText(String.format("Score: 0"));
		mTextBravoVersion = (TextView) mMainActivity.findViewById(R.id.BravoVersion);
		mTextBravoVersion.setText(String.format("Bravo13.1"));
		mTextTimeStemp = (TextView) mMainActivity.findViewById(R.id.HealthTopLeft);
		mTextTimeStemp.setText(String.format("Health: 100%%")); //
		mTextBottomRight = (TextView) mMainActivity.findViewById(R.id.TextBottomRight);
		mTextBottomRight.setText(String.format(""));
		mTextMiddle = (TextView) mMainActivity.findViewById(R.id.TextMiddle);
		mTextMiddle.setText(String.format(""));
		myRobotGameplay = new roboRebe(this);

		mGameTimer = new GameTimer(mMainActivity);
		mGameTimer.start();

		mRandomGenerator = new Random();

		flagForDebug = true;
	}

	public void printMiddle(String text){
		final String msg = text;
		mMainActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                // This code will always run on the UI thread, therefore is safe to modify UI elements.
            	mTextMiddle.setText(String.format(msg));
            }
        });
	}

	public void printTopRight(String text){
		final String msg = text;
		mMainActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                // This code will always run on the UI thread, therefore is safe to modify UI elements.
            	mTextDebug.setText(String.format(msg));
            }
        });
	}

	public void printTopLeft(String text){
		final String msg = text;
		mMainActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                // This code will always run on the UI thread, therefore is safe to modify UI elements.
            	mTextTimeStemp.setText(String.format(msg));
            }
        });
	}

	public void printBottomRight(String text){
		final String msg = text;
		mMainActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                // This code will always run on the UI thread, therefore is safe to modify UI elements.
            	mTextBottomRight.setText(String.format(msg));
            }
        });
	}

	public int CoinDistribution(boolean genarateNewCoin){
		if (genarateNewCoin == true){
			mCoinDistribution = mRandomGenerator.nextInt(mNumOfTowers);
			mMainActivity.tracking.setCoinDistribution(mCoinDistribution);
		}
		return mCoinDistribution;
	}

	public boolean GameIsRuning(){
		return gameStarted;
	}

	public void GameStarted(){
		gameStarted = true;
		CoinDistribution(true); //Generating new coin
	}

	public void rotateCoin(){
		for(int i = 0; i < mNumOfTowers; i++){
			if (mMainActivity.tracking.mDetectorArry[i].hasCoin() == true){
				mMainActivity.tracking.mDetectorArry[i].updateCoinAngle();
				break;
			}
		}
	}

	public void objCheck(){
		printDebug();
		direction js = direction.keepGO;
		direction laserDirection = direction.keepGO;
		if(mMainActivity.tracking.myRobot.isDetected()){
			js = objHitCheck();
			laserDirection = laserHit();
			if(laserDirection != direction.keepGO){
				js = laserDirection;
			}
			coinCollect();
		}else{
			js = robNotFound();
		}
		sendJS(js);
	}

	private void printDebug() {
		double rollAngle = mMainActivity.mGLView.mRenderer.getRollAngle();
		float t0 = mMainActivity.tracking.mDetectorArry[0].getFront2BackLengthInRealWorld(rollAngle);
		float t1 = mMainActivity.tracking.mDetectorArry[1].getFront2BackLengthInRealWorld(rollAngle);
		float t2 = mMainActivity.tracking.mDetectorArry[2].getFront2BackLengthInRealWorld(rollAngle);
		float t3 = mMainActivity.tracking.mDetectorArry[3].getFront2BackLengthInRealWorld(rollAngle);
		printBottomRight("rollAngle: " + rollAngle + "\nt0 length: " + t0 + "\nt1 length: " + t1 + "\nt2 length: " + t2 + "\nt3 length: " + t3);
	}

	public direction laserHit() {
		double rollAngle = mMainActivity.mGLView.mRenderer.getRollAngle();
		float sizeFactor = 2;
		float robSize = mMainActivity.tracking.myRobot.getFront2BackLength();
		for(int i = 0; i < mNumOfTowers; i++){
			if(!mMainActivity.tracking.mDetectorArry[i].isDetected()){
				continue;
			}
			if(mMainActivity.tracking.mDetectorArry[i].hasLaser()){
				float objCenterX = mMainActivity.tracking.mDetectorArry[i].getMiddleX();
				float objCenterY = mMainActivity.tracking.mDetectorArry[i].getMiddleY();
				float objBackX = mMainActivity.tracking.mDetectorArry[i].getBackX();
				float objBackY = mMainActivity.tracking.mDetectorArry[i].getBackY();
				float objFrontX = mMainActivity.tracking.mDetectorArry[i].getFrontX();
				float objFrontY = mMainActivity.tracking.mDetectorArry[i].getFrontY();
				double objIncline = -Math.tan(mMainActivity.tracking.mDetectorArry[i].getAngleFromXAxisInRadians());
				double objConst = objCenterY - objCenterX*objIncline;
				mMainActivity.tracking.myRobot.drawLaserLine(mMainActivity.tracking.mRgba,-1,(int)(objIncline*-1+objConst),1900,(int)(objIncline*1900+objConst)); //debug
				double centersDist = getLineDist(objIncline,-1,objConst,mMainActivity.tracking.myRobot.getMiddleX(),
						mMainActivity.tracking.myRobot.getMiddleY());

				double sizeDistRatio = centersDist/robSize;
				if ( sizeDistRatio < sizeFactor ){ //TODO: find optimal
					//stop robot and let it drive only one way
					float distBack = getDistInRealWorld(mMainActivity.tracking.myRobot.getMiddleX(),
							mMainActivity.tracking.myRobot.getMiddleY(),
							objBackX, objBackY,rollAngle);
					float distFront = getDistInRealWorld(mMainActivity.tracking.myRobot.getMiddleX(),
							mMainActivity.tracking.myRobot.getMiddleY(),
							objFrontX, objFrontY,rollAngle);
					if(distBack < distFront){
						return direction.keepGO;
					} else {
						if(!laserHitFlag){
							myRobotGameplay.updateHealth(roboHealth.laser);
						}
						laserHitFlag = true;
						return direction.stop;
					}
				}
			}
		}
		return direction.keepGO;
	}

	public direction objHitCheck(){
		double rollAngle = mMainActivity.mGLView.mRenderer.getRollAngle();
		float sizeFactor = 3.5f;
		float robSize = mMainActivity.tracking.myRobot.getFront2BackLength();
		for(int i = 0; i < mNumOfTowers; i++){
			if(!mMainActivity.tracking.mDetectorArry[i].isDetected()){
				continue;
			}
			float objCenterX = mMainActivity.tracking.mDetectorArry[i].getMiddleX();
			float objCenterY = mMainActivity.tracking.mDetectorArry[i].getMiddleY();
			float centersDist = getDistInRealWorld(mMainActivity.tracking.myRobot.getMiddleX(),
					mMainActivity.tracking.myRobot.getMiddleY(),
					objCenterX, objCenterY,rollAngle);
			float sizeDistRatio = centersDist/robSize;
			if ( sizeDistRatio < sizeFactor ){ //TODO: find optimal
				//stop robot and let it drive only one way

				float distBack = getDistInRealWorld(mMainActivity.tracking.myRobot.getBackX(),
						mMainActivity.tracking.myRobot.getBackY(),
						objCenterX, objCenterY,rollAngle);
				float distFront = getDistInRealWorld(mMainActivity.tracking.myRobot.getFrontX(),
						mMainActivity.tracking.myRobot.getFrontY(),
						objCenterX, objCenterY,rollAngle);
				if(!towerHitFlag){
					myRobotGameplay.updateHealth(roboHealth.obstacle);
				}
				towerHitFlag = true;
				if(distBack < distFront){
					//send only front
					framePrints(true,direction.front,i);
					return direction.front;

				} else {
					//send only back
					framePrints(true,direction.back,i);
					return direction.back;
				}
			}
		}
		framePrints(false,direction.back,0);
		towerHitFlag = false;
		return direction.keepGO;
	}

	private void framePrints(Boolean hit, direction directionMove, int towerNum) {
		// TODO
		if (hit) {
			double rollAngle = mMainActivity.mGLView.mRenderer.getRollAngle();
			mMainActivity.tracking.mDetectorArry[towerNum].drawHitCirclel(mMainActivity.tracking.mRgba, rollAngle, 2);
			if (directionMove == direction.back) {
				printMiddle("HIT: GO BACK");
			} else {
				printMiddle("HIT: GO FORTH");
			}
		}else{
			printMiddle("");
		}
	}

	public void coinCollect(){
		double rollAngle = mMainActivity.mGLView.mRenderer.getRollAngle();
		float sizeFactor = 1f;
		float robSize = mMainActivity.tracking.myRobot.getFront2BackLength();
		for(int i = 0; i < mNumOfTowers; i++){
			if(!mMainActivity.tracking.mDetectorArry[i].isDetected()){
				continue;
			}
			float objCenterX = mMainActivity.tracking.mDetectorArry[i].getCoinX();
			float objCenterY = mMainActivity.tracking.mDetectorArry[i].getCoinY();
			float centersDist = getDistInRealWorld(mMainActivity.tracking.myRobot.getMiddleX(),
					mMainActivity.tracking.myRobot.getMiddleY(),
					objCenterX, objCenterY,rollAngle);
			float sizeDistRatio = centersDist/robSize;
			if ( sizeDistRatio < sizeFactor ){ //TODO: find optimal
				myRobotGameplay.updateScore(10);
				CoinDistribution(true);
			}
		}
	}

	public void sendJS(direction js){
		double jsX = mMainActivity.joystick.getX();
		double jsY = mMainActivity.joystick.getY();
		if(js == direction.back){
			mMainActivity.joystick.haltDrive(true);
			if(jsX < 45 && jsX > -45 && jsY < 0){
				mMainActivity.joystick.haltDrive(false);
			}
		}else if(js == direction.front){
			mMainActivity.joystick.haltDrive(true);
			if(jsX < 45 && jsX > -45 && jsY > 0){
				mMainActivity.joystick.haltDrive(false);
			}
		}else if(js == direction.stop){
			mMainActivity.joystick.haltDrive(true);
		}else{
			mMainActivity.joystick.haltDrive(false);
		}
	}

	public direction robNotFound(){
		//send robot not to move
		return direction.stop;
	}

	public float getDistInRealWorld(float frontX, float frontY, float backX, float backY, double rollAngle) {
		double lengthX = (double)(frontX - backX);
		if (rollAngle > 40){
			rollAngle = rollAngle*0.9 + 4;
		}
		if (rollAngle > 60){
			rollAngle = 60;
		}
		double lengthY = ((double)(frontY - backY)) / Math.cos(Math.toRadians(rollAngle));
		return (float)Math.sqrt((double)(lengthX*lengthX + lengthY*lengthY));
	}

	public double getLineDist(double a, double b, double c, double x, double y) {
		return Math.abs(a*x+b*y+c)/Math.sqrt(a*a+b*b);
	}

	public int laserDistribution(boolean genarateLazer){
		if (genarateLazer == true){
			mLazerDistribution = mRandomGenerator.nextInt(mNumOfTowers);
		}
		return mLazerDistribution;
	}

	public void laserOn(){
		mMainActivity.tracking.mDetectorArry[mLazerDistribution].setLaser(true);
	}

	public void laserOff(){
		for(int i = 0; i < mNumOfTowers; i++){
			mMainActivity.tracking.mDetectorArry[i].setLaser(false);
		}
		laserHitFlag = false;
	}

	public void laserWarningOn(){
		mMainActivity.tracking.mDetectorArry[mLazerDistribution].setLaserWarning(true);
	}

	public void laserWarningOff(){
		for(int i = 0; i < mNumOfTowers; i++){
			mMainActivity.tracking.mDetectorArry[i].setLaserWarning(false);
		}
	}
}

/*try {
if (flag == true){
	flag = false;
	mTextDebug.setText(String.format("try"));
}
} catch (Exception e) {
Log.d(TAG, "catch :" + e.getMessage());
}*/


text:
require 'rake'
require 'rake/tasklib'
require 'tempfile'
require 'fileutils'

module Samus
  module Rake
    module Helpers
      private

      def release_version
        return @version if defined?(@version)
        raise "Missing VERSION=X.Y.Z" unless ENV['VERSION']
        @version = ENV['VERSION'].sub(/^v/, '')
      end

      def release_image
        return @image if defined?(@image)
        @image = "samus/release/#{File.basename(Dir.pwd)}:v#{release_version}"
      end
    end

    class DockerReleaseTask < ::Rake::TaskLib
      include Helpers

      PREP_DIR = '.samusprep'
      DEFAULT_DOCKERFILE = "Dockerfile.samus"

      attr_accessor :dockerfile

      attr_accessor :delete_image_after_publish

      attr_accessor :git_pull_before_build

      attr_accessor :git_pull_after_publish

      attr_accessor :mount_samus_config

      attr_accessor :extra_config

      def initialize(namespace = :samus)
        @namespace = namespace
        @dockerfile = DEFAULT_DOCKERFILE
        @delete_image_after_publish = true
        @git_pull_before_build = true
        @git_pull_after_publish = true
        @mount_samus_config = false
        @extra_config = {}

        yield self if block_given?

        build_config_files
        define
      end

      private

      def build_config_files
        @config_files = {
          Samus::CONFIG_PATH => '.samus',
          File.expand_path('~/.gitconfig') => '.gitconfig'
        }.merge(extra_config)
        @config_files.select! {|src, _dst| File.exist?(src) }
      end

      def copy_prep
        FileUtils.rm_rf(PREP_DIR)
        FileUtils.mkdir_p(PREP_DIR)
        @config_files.each do |src, dst|
          FileUtils.cp_r(src, File.join(PREP_DIR, dst))
        end
      end

      def build_or_get_dockerfile
        return dockerfile if File.exist?(dockerfile)
        fname = File.join(PREP_DIR, 'Dockerfile')
        config_copies = @config_files.values.map {|f| "COPY ./#{PREP_DIR}/#{f} /root/#{f}" }
        File.open(fname, 'w') do |f|
          f.puts([
            "FROM lsegal/samus:build",
            "ARG VERSION",
            "ENV VERSION=${VERSION}",
            "COPY . /build",
            config_copies.join("\n"),
            "RUN rm -rf /build/.samusprep",
            "RUN samus build --skip-restore ${VERSION}"
          ].join("\n"))
        end
        fname
      end

      def define
        namespace(@namespace) do
          desc '[VERSION=X.Y.Z] Builds a Samus release using Docker'
          task :build do
            img = release_image
            ver = release_version
            sh "git pull" if git_pull_before_build

            begin
              copy_prep
              sh "docker build . --rm -t #{img} -f #{build_or_get_dockerfile} --build-arg VERSION=#{ver}"
            ensure
              FileUtils.rm_rf(PREP_DIR)
            end
          end

          desc '[VERSION=X.Y.Z] Publishes a built release using Docker'
          task :publish do
            img = release_image
            mount = mount_samus_config ? "-v #{Samus::CONFIG_PATH}:/root/.samus:ro" : ''
            sh "docker run #{mount} --rm #{release_image}"
            ::Rake::Task["#{@namespace}:clean"].execute if delete_image_after_publish
            sh "git pull" if git_pull_after_publish
          end

          desc '[VERSION=X.Y.Z] Inspects a built release using Docker shell'
          task :inspect do
            sh "docker run -it --entrypoint sh #{release_image}"
          end

          desc '[VERSION=X.Y.Z] Removes a built release using Docker'
          task :clean do
            sh "docker rmi -f #{release_image}"
          end
        end
      end
    end

    class ReleaseTask < ::Rake::TaskLib
      include Helpers

      attr_accessor :git_pull_before_build
      attr_accessor :git_pull_after_publish
      attr_accessor :buildfile
      attr_writer :zipfile

      def initialize(namespace = :samus)
        @namespace = namespace
        @buildfile = ""
        @zipfile = nil
        @git_pull_before_build = true
        @git_pull_after_publish = true
        yield self if block_given?
        define
      end

      private

      def zipfile
        @zipfile || "release-v#{release_version}.tar.gz"
      end

      def define
        namespace(@namespace) do
          desc '[VERSION=X.Y.Z] Builds a Samus release'
          task :build do
            sh "git pull" if git_pull_before_build
            sh "samus build -o #{zipfile} #{release_version} #{buildfile}"
          end

          desc '[VERSION=X.Y.Z] Publishes a built release'
          task :publish do
            sh "samus publish #{zipfile}"
            sh "git pull" if git_pull_after_publish
          end
        end
      end
    end
  end
end


text:
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>mkrjs clp demos</title>
</head>

<body>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/1.19.1/TweenMax.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/1.19.1/plugins/TextPlugin.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/1.19.1/plugins/ScrollToPlugin.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/1.19.1/plugins/CSSRulePlugin.min.js"></script>

  <script src="../downloads/mkr.js"></script>
  <script src="../downloads/constructs/svg/clp.js"></script>

  <script type="text/javascript">
    var m = new mkr({
      css:{width:600, height:300, background:'grey'},
      tmln:{paused:true, repeat:-1, yoyo:false}
    });

    //create a new clp instance using the construct method
    var c1 = m.construct('clp', {
      clips:[ //define svg elements the clippath is initialized with
        ['rect',    {attr:{x:30, y:0, width:150, height:120, fill:'blue'}}], //each entry should be a 2-member array
        ['circle',  {attr:{cx:40, cy:30, r:0, fill:'red'}}] //the svg tagname followed by and options object
      ],

      targets:[ //define svg elements the clippath will target
        ['rect',    {attr:{x:50, y:25, width:40, height:50, fill:'red'}}], //each entry should be a 2-member array
        ['circle',  {attr:{cx:55, cy:45, r:15, fill:'blue'}}] //the svg tagname followed by and options object
      ]
    });

    //additional clips can be created using the create method
    c1.create('ellipse', {attr:{cx:100, cy:30, rx:0, ry:0, fill:'white', alpha:.4}})

    //additional targets can be created using the createTarget method
    c1.createTarget('ellipse', {attr:{cx:120, cy:75, rx:20, ry:45, fill:'green'}})

    //get a reference to the exising svg element
    var s = mkr.query('svg');

    //create an ellipse
    var e = m.create('ellipse', {
      attr:{
        cx:220, cy:120, width:100, height:100, 'stroke-width':15,
        fill:"cyan",
        stroke:"black"
      }
    }, s)

    //the clp can be assigned to additional targets using the assing method
    c1.assign(e);

    //create an svg rect...
    m.create('rect', {
      attr:{
        x:0, y:0, width:200, height:100, 'stroke-width':3,
        fill:"magenta"
      }, css:{
        alpha:.3,
        clipPath: c1.url //the clp can also employed by assigning its url to another element
      }
    }, s) //notice that we are adding svg elements to the root svg

    //and of course gsap can animate any property/attribute

    //animate the offset of the 2nd stop used in the border gradient
    m.tmln.to(mkr.query('#'+c1._id+' rect'), 1, {attr:{width:0, height:0}});
    m.tmln.to(mkr.query('#'+c1._id+' circle'), 1, {attr:{cx:130, cy:50, r:'+=60'}});
    m.tmln.to(mkr.query('#'+c1._id+' circle'), 1, {attr:{cx:0, cy:0, r:0}});
    m.tmln.to(mkr.query('#'+c1._id+' ellipse'), 1, {attr:{rx:130, ry:50}});
    m.tmln.to(mkr.query('#'+c1._id+' ellipse'), 1, {attr:{rx:0, ry:0}});
    m.tmln.to(mkr.query('#'+c1._id+' rect'), 1, {attr:{width:'+=150', height:'+=120'}});

    //create a button/click listener to toggle animation
    m.create('div', {attr:{id:'clickMe'}, css:{cursor:'pointer', textAlign:'center', x:10, y:120, width:130, height:25, padding:'10px', lineHeight:'25px', borderRadius:5, background:'red', color:'white'}, text:'Click to animate'});

    mkr.on('#clickMe', 'click', function() {
      if(m.tmln.paused()) {
        m.tmln.play();
        TweenMax.set('#clickMe', {text:'Click to pause'});
      }
      else {
        m.tmln.pause();
        TweenMax.set('#clickMe', {text:'Click to animate'})
      }
    });
  </script>
</body>
</html>


text:
@implementation SDLImageField

- (instancetype)init {
    if (self = [super init]) {
    }
    return self;
}

- (instancetype)initWithDictionary:(NSMutableDictionary *)dict {
    if (self = [super initWithDictionary:dict]) {
    }
    return self;
}

- (void)setName:(SDLImageFieldName *)name {
    if (name != nil) {
        [store setObject:name forKey:NAMES_name];
    } else {
        [store removeObjectForKey:NAMES_name];
    }
}

- (SDLImageFieldName *)name {
    NSObject *obj = [store objectForKey:NAMES_name];
    if (obj == nil || [obj isKindOfClass:SDLImageFieldName.class]) {
        return (SDLImageFieldName *)obj;
    } else {
        return [SDLImageFieldName valueOf:(NSString *)obj];
    }
}

- (void)setImageTypeSupported:(NSMutableArray *)imageTypeSupported {
    if (imageTypeSupported != nil) {
        [store setObject:imageTypeSupported forKey:NAMES_imageTypeSupported];
    } else {
        [store removeObjectForKey:NAMES_imageTypeSupported];
    }
}

- (NSMutableArray *)imageTypeSupported {
    NSMutableArray *array = [store objectForKey:NAMES_imageTypeSupported];
    if ([array count] < 1 || [[array objectAtIndex:0] isKindOfClass:SDLFileType.class]) {
        return array;
    } else {
        NSMutableArray *newList = [NSMutableArray arrayWithCapacity:[array count]];
        for (NSString *enumString in array) {
            [newList addObject:[SDLFileType valueOf:enumString]];
        }
        return newList;
    }
}

- (void)setImageResolution:(SDLImageResolution *)imageResolution {
    if (imageResolution != nil) {
        [store setObject:imageResolution forKey:NAMES_imageResolution];
    } else {
        [store removeObjectForKey:NAMES_imageResolution];
    }
}

- (SDLImageResolution *)imageResolution {
    NSObject *obj = [store objectForKey:NAMES_imageResolution];
    if (obj == nil || [obj isKindOfClass:SDLImageResolution.class]) {
        return (SDLImageResolution *)obj;
    } else {
        return [[SDLImageResolution alloc] initWithDictionary:(NSMutableDictionary *)obj];
    }
}

@end


text:
struct encryption_ctx {
    EVP_CIPHER_CTX* ctx;
    uint8_t status;
    unsigned char iv[16];
    size_t iv_len;
    size_t bytes_remaining; // only for libsodium
    uint64_t ic; // only for libsodium
    uint8_t cipher;
};

#define STATUS_EMPTY 0
#define STATUS_INIT 1
#define STATUS_DESTORYED 2

#define kShadowsocksMethods 13

const char *shadowsocks_encryption_names[];

void encrypt_buf(struct encryption_ctx* ctx, unsigned char *buf, size_t *len);
void decrypt_buf(struct encryption_ctx* ctx, unsigned char *buf, size_t *len);

int send_encrypt(struct encryption_ctx* ctx, int sock, unsigned char *buf, size_t *len, int flags);
int recv_decrypt(struct encryption_ctx* ctx, int sock, unsigned char *buf, size_t *len, int flags);

void init_encryption(struct encryption_ctx* ctx);
void cleanup_encryption(struct encryption_ctx* ctx);

void config_encryption(const char *password, const char *method);

unsigned char *shadowsocks_key;


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "file://zonbook/docbookx.dtd"[
    <!ENTITY % phrases-shared SYSTEM "file://AWSShared/common/phrases-shared.ent">
    %phrases-shared;
]>
<block>

    <para>
        Shows how to use the &JSBlong; (v3) to create a web application that tracks work
        items in an &AURlong; database and emails reports by using &SESlong; (&SES;).
        This example uses a front end built with React.js to interact with an Express
        Node.js backend.
    </para>
    <para>
        <itemizedlist>
            <listitem><para>Integrate a React.js web application with &AWS-services;.</para></listitem>
            <listitem><para>List, add, and update items in an &AUR; table.</para></listitem>
            <listitem><para>Send an email report of filtered work items by using &SES;.</para></listitem>
            <listitem><para>Deploy and manage example resources with the included &CFNlong; script.</para></listitem>
        </itemizedlist>
    </para>
    <para>
        For complete source code and instructions on how to set up and run, see the full example on
        <ulink url="https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app">GitHub</ulink>.
    </para>

</block>


text:
require 'json'

module SolidusMailchimpSync
  # Intentionally does not sync images, let variants do that.
  #
  class ProductSerializer
    attr_reader :product

    def initialize(product)
      @product = product
      unless product.persisted?
        raise ArgumentError, "Can't serialize a non-saved product: #{product}"
      end
    end

    # We have to include image and URL for certain mailchimp features,
    # although Mailchimp does NOT let us update/edit a sync'd product, grr.
    def as_json
      hash = {
        id: product.id.to_s,
        handle: product.slug,
        title: product.name,
        description: product.description,
        variants: variants_json
      }

      if url = self.url
        hash[:url] = url
      end

      if image_url = self.image_url
        hash[:image_url] = image_url
      end

      if product.available_on
        hash[:published_at_foreign] = product.available_on.utc.iso8601
      end

      hash
    end

    # Override in custom serializer for custom front-end url
    def url
      if Rails.application.routes.default_url_options[:host] && Spree::Core::Engine.routes.url_helpers.respond_to?(:product_url)
        Spree::Core::Engine.routes.url_helpers.product_url(product,
          host: Rails.application.routes.default_url_options[:host],
          protocol: Rails.application.config.force_ssl ? "https" : "http")
      end
    end

    # Override in custom serializer if you want to choose which image different than `first`
    def image_url
      product.images.first.try(:attachment).try(:url)
    end

    def variants_json
      sellable_variants.collect do |variant|
        VariantSynchronizer.new(variant).serializer.as_json
      end
    end

    def sellable_variants
      if (product.association(:variants).loaded? ? product.variants.length > 0 : product.variants.exists?)
        product.variants
      else
        [product.master]
      end
    end

    def to_json
      JSON.dump(as_json)
    end
  end
end


text:
package com.reactlibrary.net.injection;

public interface HasComponent<C> {
    C getComponent();
}


text:
<!doctype html public "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">

    <title>PHPXRef 0.7.1 : Unnamed Project : Detail view of bonfire_models.md</title>
    <link rel="stylesheet" href="../../sample.css" type="text/css">
    <link rel="stylesheet" href="../../sample-print.css" type="text/css" media="print">

    <meta http-equiv="content-type" content="text/html;charset=iso-8859-1">

            [ Index ]

PHP Cross Reference of Unnamed Project

[ Show Explorer ]
[ Hide Navbar ]

title

Body

[close]

/bonfire/docs/ -> bonfire_models.md (summary)

[Source view]
[Print]
[Project Stats]

(no description)

File Size: 	768 lines (32 kb)

Included or required:	0 times

Referenced: 	0 times

Includes or requires: 	0 files

Defines 2 classes

X_model:: (0 methods):

User_model:: (5 methods):

  find_all()

  prep_data()

  save_user()

  find()

  set_created_on()

Class: X_model  - X-Ref

Class: User_model  - X-Ref

find_all()
X-Ref

No description

prep_data($post_data)
X-Ref

No description

save_user($type='insert', $id=0, $meta_fields=array()
X-Ref

No description

find($id=null)
X-Ref

No description

set_created_on($row)
X-Ref

No description

Generated: Thu Oct 23 19:15:14 2014
	Cross-referenced by PHPXref 0.7.1


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<resultset xmlns="http://www.appng.org/schema/platform" hits="2" lastchunk="0" firstchunk="0" previouschunk="0"
	nextchunk="0" chunksize="2" chunkname="action" chunk="0">
	<result selected="true">
		<field type="text" name="name">
			<value>Princess</value>
		</field>
		<field type="text" name="firstname">
			<value>Lea</value>
		</field>
		<field type="date" name="birthDate">
			<value></value>
		</field>
		<field type="decimal" name="size">
			<value></value>
		</field>
		<field type="decimal" name="savings">
			<value></value>
		</field>
		<field type="list:checkbox" name="integerList">
			<value></value>
		</field>
		<field type="file" name="picture">
			<value></value>
		</field>
		<field type="file-multiple" name="morePictures">
			<value></value>
		</field>
		<field type="list:text" name="strings">
			<value></value>
		</field>
		<field type="coordinate" name="coordinate">
			<field type="decimal" name="latitude">
				<value>12.23</value>
			</field>
			<field type="decimal" name="longitude">
				<value>34.36</value>
			</field>
			<value></value>
		</field>
		<field type="image" name="images">
			<value />
			<icon type="class">/foo/bar1.jpg</icon>
			<icon type="class">/foo/bar2.jpg</icon>
		</field>
		<field name="father">
			<field type="text" name="name">
				<value>Darth</value>
			</field>
			<field type="text" name="firstname">
				<value>Vader</value>
			</field>
		</field>
		<linkpanel location="inline" id="thepanel">
			<link target="/foobar/foo/1/Lea/Princess" mode="intern" id="2">
				<confirmation params="#{name}" id="some.label">some.label[#{name}]</confirmation>
			</link>
		</linkpanel>
	</result>
	<result>
		<field type="text" name="name">
			<value>Skywalker</value>
		</field>
		<field type="text" name="firstname">
			<value>Luke</value>
		</field>
		<field type="date" name="birthDate">
			<value></value>
		</field>
		<field type="decimal" name="size">
			<value>1.85</value>
		</field>
		<field type="decimal" name="savings">
			<value>123,456.357</value>
		</field>
		<field type="list:checkbox" name="integerList">
			<value></value>
		</field>
		<field type="file" name="picture">
			<value></value>
		</field>
		<field type="file-multiple" name="morePictures">
			<value></value>
		</field>
		<field type="list:text" name="strings">
			<value></value>
		</field>
		<field type="coordinate" name="coordinate">
			<field type="decimal" name="latitude">
				<value>17.23</value>
			</field>
			<field type="decimal" name="longitude">
				<value>14.36</value>
			</field>
			<value></value>
		</field>
		<field type="image" name="images">
			<value />
			<icon type="class">/foo/bar1.jpg</icon>
			<icon type="class">/foo/bar2.jpg</icon>
		</field>
		<field name="father">
			<field type="text" name="name">
				<value>Darth</value>
			</field>
			<field type="text" name="firstname">
				<value>Vader</value>
			</field>
		</field>
		<linkpanel location="inline" id="thepanel">
			<link target="/foobar/foo/2/Luke/Skywalker" mode="intern" id="2">
				<confirmation params="#{name}" id="some.label">some.label[#{name}]</confirmation>
			</link>
		</linkpanel>
	</result>
</resultset>


text:
package org.apache.harmony.beans.tests.java.beans;

import java.beans.IntrospectionException;

import junit.framework.TestCase;

import org.apache.harmony.testframework.serialization.SerializationTest;

/**
 * Unit test of IntrospectionException.
 */

public class IntrospectionExceptionTest extends TestCase {

    public void testConstructor() {
        String message = "IntrospectionExceptionTest";
        IntrospectionException e = new IntrospectionException(message);
        assertSame(message, e.getMessage());
    }

    public void testConstructor_MessageNull() {
        IntrospectionException e = new IntrospectionException(null);
        assertNull(e.getMessage());
    }

    /**
     * @tests serialization/deserialization.
     */
    public void testSerializationSelf() throws Exception {

        SerializationTest.verifySelf(new IntrospectionException(
                "IntrospectionExceptionTest"));
    }

    /**
     * @tests serialization/deserialization compatibility with RI.
     */
    public void testSerializationCompatibility() throws Exception {

        SerializationTest.verifyGolden(this, new IntrospectionException(
                "IntrospectionExceptionTest"));
    }

    public void testIntrospectionExceptionMessage() {
        // Regression for HARMONY-235
        IntrospectionException e = new IntrospectionException("test message");
        assertEquals("test message", e.getMessage());
    }
}