text:
// TODO: revise documentation
/**
 * KnowledgeStore core API ({@code ks-core}).
 *
 *
Data model

 *

 * A total ordering relation is defined on nodes, allowing to compare any node against any other
 * node. This relation generalizes the single ordering relation that can be naturally defined for
 * specific types of nodes, and is provided for ease of use (e.g., to provide a canonical way to
 * order nodes) and for simplifying the definition of conditions on nodes. More in details, scalar
 * nodes are different and are sorted before record nodes, while specific rules are applied for
 * ordering among scalars and among records (see, respectively, the documentation for
 * {@link Record} and {@link Scalar}).
 *

 *

 * Resources. A resource is a self-contained piece of unstructured content, such as a news
 * article or a multimedia object, having some descriptive metadata (e.g., from
 * {@link org.openrdf.model.vocabulary.DCTERMS} vocabulary), a binary representation (
 * {@link eu.fbk.knowledgestore.vocabulary.KS#STORED_AS}) and zero or more mentions contained
 * within it ({@link eu.fbk.knowledgestore.vocabulary.KS#HAS_MENTION} ). Note that (1)
 * representation metadata is generated automatically by the system based on the uploaded content,
 * so there is no need to manually set it; and (2) the actual binary data is not available through
 * the resource record object, but must be instead accessed using other API methods of the
 * KnowledgeStore.
 *

 *

 * Representations. A digital representation is possibly stored for each resource in the
 * KnowledgeStore. A {@code Representation} record contains the metadata of such a representation,
 * while its actual binary content can be accessed via the {@code Representation} class using
 * specific methods of the KnowledgeStore API. The representation metadata stored by this kind of
 * record comprise the filename ({@link eu.fbk.knowledgestore.vocabulary.NFO#FILE_NAME}), the size
 * in bytes ( {@link eu.fbk.knowledgestore.vocabulary.NFO#FILE_SIZE} ), the date and time the
 * representation was created ({@link eu.fbk.knowledgestore.vocabulary.NFO#FILE_CREATED}) and the
 * MIME type (see {@link eu.fbk.knowledgestore.vocabulary.NIE#MIME_TYPE}). Representation records
 * are automatically created by the system for stored resources.
 *

 *

 * Mentions. A mention is a snippet of a resource (
 * {@link eu.fbk.knowledgestore.vocabulary.KS#MENTION_OF}), such as some characters in a text
 * document or some pixels in an image, that may refer to some entity of interest (
 * {@link eu.fbk.knowledgestore.vocabulary.KS#REFERS_TO}). Mentions can be automatically extracted
 * by natural language and multimedia processing tools, that can enrich them with additional
 * attributes about how they denote their referent (e.g., name, qualifiers, 'sentiment').
 * Therefore, mentions present both unstructured and structured facets not available in resources
 * and entities layers alone, and are thus a valuable source of information on their own. A number
 * of axioms ( {@link eu.fbk.knowledgestore.vocabulary.KS#EXPRESSES}) may be expressed by the
 * mention, i.e., can be extracted from its snippet and attributes.
 *

 *

 * Entities. An entity is described by a (possibly empty) set of axioms (
 * {@link eu.fbk.knowledgestore.vocabulary.KS#DESCRIBED_BY}) and is referred by a (possibly empty)
 * set of mentions ( {@link eu.fbk.knowledgestore.vocabulary.KS#REFERRED_BY}).
 *

 *

 * Axioms. Axioms describe entities of the KnowledgeStore. An axiom is encoded by a set of
 * RDF statements ({@link eu.fbk.knowledgestore.vocabulary.KS#ENCODED_BY}) that relate one or more
 * entities and its validity may be restricted to a specific <it>context</it> (
 * {@link eu.fbk.knowledgestore.vocabulary.KS#HOLDS_IN}); an axiom may be annotated with
 * additional metadata and can be expressed by a number of mentions (
 * {@link eu.fbk.knowledgestore.vocabulary.KS#EXPRESSED_BY}). Note that a null context is used in
 * case of axioms holding universally and not in a specific context. An axiom may be simple
 * or complex, with the first consisting of exactly one RDF statement (possibly
 * contextualized and associated to additional metadata); simple axioms are generally used for
 * ABox assertions, while complex axioms are associated mainly to TBox declarations. Axioms IDs
 * should be assigned based on RDF statements and context.
 *

 *

 * Contexts A context defines the circumstances under which a certain axiom holds; each
 * axiom is associated exactly to a context in the KnowledgeStore (which may be shared by multiple
 * axioms) via the {@link eu.fbk.knowledgestore.vocabulary.KS#HOLDS_IN} property (if null, the
 * axiom holds universally). A context is identified by a set of attributes or contextual
 * dimensions, which are the properties of the context record. IDs of context records should
 * be assigned based on all the values of all the contextual dimensions.
 *

 */
@javax.annotation.ParametersAreNonnullByDefault
package eu.fbk.knowledgestore;

import eu.fbk.knowledgestore.data.Record;

// NOTES ON AXIOMS
// - may add enum Axiom.Kind and method Kind getKind() for retrieving the type of ABox/TBox
// axiom.
// Types would be
// SUB_CLASS rdfs:subClassOf
// EQUIVALENT_CLASSES owl:equivalentClass // also for DatatypeDefinition
// DISJOINT_CLASSES owl:disjointWith, owl:AllDisjointClasses**** (type)
// DISJOINT_UNION owl:disjointUnionOf***
// SUB_PROPERTY rdfs:subPropertyOf
// PROPERTY_CHAIN owl:propertyChainAxiom***
// EQUIVALENT_PROPERTIES owl:equivalentProperty
// DISJOINT_PROPERTIES owl:propertyDisjointWith, owl:AllDisjointProperties*** (type)
// PROPERTY_DOMAIN rdfs:domain
// PROPERTY_RANGE rdfs:range
// INVERSE_PROPERTIES owl:inverseOf
// FUNCTIONAL_PROPERTY owl:FunctionalProperty
// INVERSE_FUNCTIONAL_PROPERTY owl:InverseFunctionalProperty
// REFLEXIVE_PROPERTY owl:ReflexiveProperty
// IRREFLEXIVE_PROPERTY owl:IrreflexiveProperty
// SYMMETRIC_PROPERTY owl:SymmetricProperty
// ASYMMETRIC_PROPERTY owl:AsymmetricProperty
// TRANSITIVE_PROPERTY owl:TransitiveProperty
// KEY owl:hasKey***
// SAME_AS owl:sameAs
// DIFFERENT_FROM owl:differentFrom, owl:AllDifferent***
// CLASS_ASSERTION rdf:type
// PROPERTY_ASSERTION ???
// NEGATIVE_PROPERTY_ASSERTION owl:NegativePropertyAssertion


text:
namespace boost {
namespace context {

template< typename traitsT >
class basic_fixedsize_stack {
private:
    std::size_t     size_;

public:
    typedef traitsT traits_type;

    basic_fixedsize_stack( std::size_t size = traits_type::default_size() ) :
        size_( size) {
        BOOST_ASSERT( traits_type::minimum_size() <= size_);
        BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= size_) );
    }

    stack_context allocate() {
        void * vp = std::malloc( size_);
        if ( ! vp) throw std::bad_alloc();

        stack_context sctx;
        sctx.size = size_;
        sctx.sp = static_cast< char * >( vp) + sctx.size;
#if defined(BOOST_USE_VALGRIND)
        sctx.valgrind_stack_id = VALGRIND_STACK_REGISTER( sctx.sp, vp);
#endif
        return sctx;
    }

    void deallocate( stack_context & sctx) {
        BOOST_ASSERT( sctx.sp);
        BOOST_ASSERT( traits_type::minimum_size() <= sctx.size);
        BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= sctx.size) );

#if defined(BOOST_USE_VALGRIND)
        VALGRIND_STACK_DEREGISTER( sctx.valgrind_stack_id);
#endif

        void * vp = static_cast< char * >( sctx.sp) - sctx.size;
        std::free( vp);
    }
};

typedef basic_fixedsize_stack< stack_traits >  fixedsize_stack;

}}

#ifdef BOOST_HAS_ABI_HEADERS
#  include BOOST_ABI_SUFFIX
#endif

#endif // BOOST_CONTEXT_FIXEDSIZE_H

redpajama_set_name: RedPajamaGithub


text: using OpFunc = std::function<int(int, int)>;


text:
using namespace components;
using namespace entities;

namespace physics
{

  class RigidBody : public Component
  {
  public:
    RigidBody(Json::Value value, EntityPtr entity);
    ~RigidBody();

    const btTransform* getWorldTransform() const;
    void setTransform(Transform& transform);

    void createRigidBody();

    void addToWorld(btDiscreteDynamicsWorld* world);
    void removeFromWorld(btDiscreteDynamicsWorld* world);

    void applyForce(const glm::vec3 force, const glm::vec3 position = glm::vec3());

    void print(std::ostream& where) const;
  private:
    const std::string mShapeType;
    btScalar mMass;
    btScalar mRadius;

    btCollisionShape* mShape;
    btMotionState* mState;

    btRigidBody* mRigidBody;
  };

}

#endif


text:
package com.yandex.money.api.model;

import com.google.gson.annotations.SerializedName;
import com.yandex.money.api.util.Enums;

/**
 * Type of money sources allowed to make a payment.
 */
public enum AllowedMoneySource implements Enums.WithCode<AllowedMoneySource> {

    /**
     * Cards that are linked to a wallet.
     */
    @SerializedName("cards")
    CARDS("cards"),

    /**
     * Cash.
     */
    @SerializedName("cash")
    CASH("cash"),

    /**
     * Any bank card, excluding ones that are linked to a wallet.
     */
    @SerializedName("payment-card")
    PAYMENT_CARD("payment-card"),

    /**
     * Wallet.
     */
    @SerializedName("wallet")
    WALLET("wallet");

    public final String code;

    AllowedMoneySource(String code) {
        this.code = code;
    }

    @Override
    public String getCode() {
        return code;
    }

    @Override
    public AllowedMoneySource[] getValues() {
        return values();
    }
}


text:
<?php declare(strict_types = 1);

namespace DrdPlus\Tests\Tables\Body\Healing;

use DrdPlus\Codes\Body\ConditionsAffectingHealingCode;
use DrdPlus\Tables\Body\Healing\HealingByConditionsTable;
use DrdPlus\Tables\Body\Healing\HealingConditionsPercents;
use DrdPlus\Tests\Tables\TableTest;

class HealingByConditionsTableTest extends TableTest
{
    /**
     * @test
     */
    public function I_can_get_header()
    {
        $healingBonusForConditionsTable = new HealingByConditionsTable();
        self::assertSame(
            [['situation', 'bonus_from', 'bonus_to', 'can_be_more']],
            $healingBonusForConditionsTable->getHeader()
        );
    }

    /**
     * @test
     * @dataProvider provideBonusWithConditionsCode
     * @param int $conditionsPercents
     * @param int $expectedBonus
     * @param string $conditionsCode
     */
    public function I_can_get_bonus_for_every_conditions($conditionsPercents, $expectedBonus, $conditionsCode)
    {
        $healingBonusForConditionsTable = new HealingByConditionsTable();
        self::assertSame(
            $expectedBonus,
            $healingBonusForConditionsTable->getHealingBonusByConditions(
                $conditionsCode,
                $this->createHealingConditionsPercents($conditionsPercents)
            )
        );
    }

    public function provideBonusWithConditionsCode()
    {
        return [
            [0, -6, ConditionsAffectingHealingCode::FOUL_CONDITIONS /* -6, -12 */],
            [100, -12, ConditionsAffectingHealingCode::FOUL_CONDITIONS /* -6, -12 */],
            [180, -17, ConditionsAffectingHealingCode::FOUL_CONDITIONS /* -6, -12 */],
            [33, -4, ConditionsAffectingHealingCode::BAD_CONDITIONS /* -5, -3 */],
            [49, -1, ConditionsAffectingHealingCode::IMPAIRED_CONDITIONS /* -2, -1 */],
            [50, -2, ConditionsAffectingHealingCode::IMPAIRED_CONDITIONS /* -2, -1 */],
            [0, 0, ConditionsAffectingHealingCode::GOOD_CONDITIONS],
            [100, 0, ConditionsAffectingHealingCode::GOOD_CONDITIONS],
        ];
    }

    /**
     * @param int $percents
     * @return \Mockery\MockInterface|HealingConditionsPercents
     */
    private function createHealingConditionsPercents($percents)
    {
        $healingConditionsPercents = $this->mockery(HealingConditionsPercents::class);
        $healingConditionsPercents->shouldReceive('getValue')
            ->andReturn($percents);
        $healingConditionsPercents->shouldReceive('getRate')
            ->andReturn($percents / 100);

        return $healingConditionsPercents;
    }

    /**
     * @test
     */
    public function I_can_get_higher_bonus_than_hundred_percents_if_conditions_allow_it()
    {
        self::assertSame(
            -18,
            (new HealingByConditionsTable())->getHealingBonusByConditions(
                ConditionsAffectingHealingCode::FOUL_CONDITIONS,
                new HealingConditionsPercents(200)
            )
        );
    }

    /**
     * @test
     */
    public function I_can_not_get_higher_bonus_than_hundred_percents_if_conditions_do_not_allow_it()
    {
        $this->expectException(\DrdPlus\Tables\Body\Healing\Exceptions\UnexpectedHealingConditionsPercents::class);
        $this->expectExceptionMessageMatches('~101~');
        (new HealingByConditionsTable())->getHealingBonusByConditions(
            ConditionsAffectingHealingCode::IMPAIRED_CONDITIONS,
            new HealingConditionsPercents(101)
        );
    }

    /**
     * @test
     */
    public function I_can_not_get_bonus_for_unknown_condition()
    {
        $this->expectException(\DrdPlus\Tables\Body\Healing\Exceptions\UnknownCodeOfHealingInfluence::class);
        $this->expectExceptionMessageMatches('~frozen~');
        (new HealingByConditionsTable())->getHealingBonusByConditions('frozen', $this->createHealingConditionsPercents(0));
    }
}


text:
*****************
How To Contribute
*****************

=========================
Install Devel Environment
=========================

-----
Clone
-----
::

    cd /www
    mkdir /www/vaultier
    cd vaultier
    git clone git@git.rclick.cz:rclick/vaultier.git .
    git checkout stable

-------------------------
Install Required Packages
-------------------------
::

    # install backend tools
    sudo apt-get install postgresql postgresql-contrib
    sudo apt-get install python
    sudo apt-get install python-dev
    sudo apt-get install python-pip
    sudo pip install virtualenv

---------------------------------
Create Venv and setup Environment
---------------------------------
::

    virtualenv ./env
    source ./env/bin/activate
    pip install -r REQUIREMENTS
    python setup.py develop
    ./vaultier/manage.py setup

----------------------------------
Install Frontend Development Tools
----------------------------------
::

    # install frontend tools
    sudo apt-get install nodejs
    sudo apt-get install npm

    # install gulp
    sudo npm install -g gulp

    # if you are on ubuntu (14.04) or get error node not found do
    sudo ln -s /usr/bin/nodejs /usr/bin/node

    # install bower
    sudo npm install -g bower

    # initialize sources and vendors
    cd vaultier/vaultier/scripts
    sudo npm install
    bower install

========================
Run Development Instance
========================
::

    # run server
    cd vaultier
    ./manage.py setup
    ./manage.py runserver 127.0.0.0:8000
    http://127.0.0.0:8000

    # run frontend compiler
    cd vaultier/scripts
    gulp watch


text:
"use strict";

/*global define:false, $:false, window:false*/

define(
	["jquery", "bootstrap", "views"],
	function ($, bootstrap, Views) {
		/**
		 * @file Game classes used to build the happycat game.
		 * @author Beau Burke <beau@filterswept.com>
		 * @see HappycatGame
		 * @see Player
		 * @see Surface
		 */

		/**
		 * Represents the clickable surface the user interacts with.
		 * @constructor
		 * @param {jQuery} $template - Element used to display Surface objects.  The element should be block level and positionable.
		 */

		function Surface($template) {
			var surface = this;

			this.$node = $template.clone();
			this.size = {w: 200, h: 240};
			this.position = {x: 0, y: 0};
			this.velocity = {x: 0, y: 0};
			this.next = null;

			this.$node.attr("id", "");
			this.$node.css("display", "block");

			/* sometimes an accidental drag occurs when the user is clicking rapidly. this will
			 * prevent the default drag handler
			 */
			this.$node.children("img").on(
				"dragstart",
				function (evt) {
					return false;
				}
			);

			this.$node.on(
				"click",
				function (evt) {
					if (surface.onClick) {
						surface.onClick(evt);
					}
				}
			);

			this.update();
		}

		/**
		 * Sets the position of the current Surface.  The origin is at the top/left of the play field and is inverted on the x-axis.
		 * @param position.x {Number} - X coordinate to place the surface at.
		 * @param position.y {Number} - Y coordinate to place the surface at.
		 */

		Surface.prototype.setPosition = function (position) {
			this.position.x = position.x;
			this.position.y = position.y;
			this.update();
		};

		/**
		 * Changes the position of the current Surface.  The origin is at the top/left of the play field and is inverted on the x-axis.
		 * @param position.x {Number} - Delta to add to the surface's X coordinate.
		 * @param position.y {Number} - Delta to add to the surface's Y coordinate.
		 */

		Surface.prototype.move = function (delta) {
			this.position.x += delta.x;
			this.position.y += delta.y;
			this.update();
		};

		/**
		 * Sets the velocity of the current Surface.
		 * @param position.x {Number} - X trajectory of the velocity.
		 * @param position.y {Number} - Y trajectory of the velocity.
		 */

		Surface.prototype.setVelocity = function (velocity) {
			this.velocity.x = velocity.x;
			this.velocity.y = velocity.y;
		};

		/**
		 * Changes the velocity of the current Surface.
		 * @param position.x {Number} - Delta to add to the surface's X trajectory.
		 * @param position.y {Number} - Delta to add to the surface's Y trajectory.
		 */

		Surface.prototype.accellerate = function (delta) {
			this.velocity.x += delta.x;
			this.velocity.y += delta.y;
		};

		/**
		 * This method is called each time the game engine iterates.  Surface objects should update their position based on their current velocity.
		 * @param bounds.w {Number} - Width of the playing surface.
		 * @param bounds.h {Number} - Height of the playing surface.
		 */

		Surface.prototype.iterate = function (bounds) {
			var newPosition = {
				x: this.position.x + this.velocity.x,
				y: this.position.y + this.velocity.y
			};

			if (newPosition.x < 0 || (newPosition.x + this.size.w) >= bounds.w) {
				this.velocity.x = -this.velocity.x;
			}

			if (newPosition.y < 0 || (newPosition.y + this.size.h) >= bounds.h) {
				this.velocity.y = -this.velocity.y;
			}

			this.move(this.velocity);
			this.update();
		};

		/**
		 * A helper method that matches the object's DOM element with the object's internal state.
		 */

		Surface.prototype.update = function () {
			this.$node.css({
				left: this.position.x + "px",
				top: this.position.y + "px",
				width: this.size.w + "px",
				height: this.size.h + "px"
			});
		};

		/**
		 * Represents the game player.
		 * @constructor
		 */

		function Player() {
			this.load();
		}

		/**
		 * Indicates whether the current object has the system default name.
		 * @returns {Boolean} True if the player name has the system default value.  False if otherwise.
		 */

		Player.prototype.isDefaultName = function () {
			return this.name === "Player";
		};

		/**
		 * Used to notify the player object that a point has been scored.
		 */

		Player.prototype.scorePoint = function () {
			this.score += 1;
		};

		/**
		 * Saves the current player state.
		 */

		Player.prototype.save = function () {
			try {
				window.localStorage.setItem("scratch_player_name", this.name);
				window.localStorage.setItem("scratch_player_score", this.score);

			} catch (error) {
				window.document.cookies = "scratch_player_name=" + this.name;
				window.document.cookies = "scratch_player_score=" + this.score;
			}
		};

		/**
		 * Loads the saved player state.  If no saved state can be found, then default values are used instead.
		 */

		Player.prototype.load = function () {
			var readCookie = null;

			try {
				this.name = window.localStorage.getItem("scratch_player_name") || "Player";
				this.score = parseInt(window.localStorage.getItem("scratch_player_score") || "0", 10);

			} catch (error) {
				readCookie = function (name) {
					/* thanks Scott Andrew! */
					var nameEQ = name + "=",
						ca = window.document.cookie.split(';'),
						i = 0,
						c = "";

					for (i = 0; i < ca.length; i += 1) {
						c = ca[i];
						while (c.charAt(0) === ' ') {
							c = c.substring(1, c.length);
						}
						if (c.indexOf(nameEQ) === 0) {
							return c.substring(nameEQ.length, c.length);
						}
					}

					return null;
				};

				this.name = readCookie("scratch_player_name") || "Player";
				this.score = parseInt(readCookie("scratch_player_score") || "0", 10);
			}
		};

		/**
		 * Erases the saved player state.
		 */

		Player.prototype.wipeSave = function () {
			try {
				window.localStorage.removeItem("scratch_player_name");
				window.localStorage.removeItem("scratch_player_score");

			} catch (error) {
				window.document.cookies = "scratch_player_name=";
				window.document.cookies = "scratch_player_score=";
			}
		};

		/**
		 * Encapsulates all the data and rules used to play the Happycat game.
		 * @constructor
		 * @param {jQuery} $surfaceTemplate - Element used to display Surface objects.
		 */

		function HappycatGame($surfaceTemplate) {
			var game = this;

			this.$surfaceTemplate = $surfaceTemplate;
			this.player = new Player();
			this.soundEffects = new Views.Sampler();
			this.field = {
				w: $(window).width(),
				h: $(window).height()
			};

			$(window).on(
				"resize",
				function (evt) {
					game.field.w = $(this).width();
					game.field.h = $(this).height();
				}
			);

			this.addSurface();
		}

		/**
		 * Used to fire the game's onPlayerChange() handler.
		 */

		HappycatGame.prototype.triggerPlayerChange = function () {
			if (this.onPlayerChange) {
				this.onPlayerChange(this.player);
			}
		};

		/**
		 * Adds a new Surface object to the game.  The object is placed at the center of the playing field and has a random velocity.
		 * @todo Dont assume <body> is the playing field.  It should be user-definable.
		 */

		HappycatGame.prototype.addSurface = function () {
			var game = this,
				surface = new Surface(this.$surfaceTemplate);

			surface.setPosition({
				x: Math.floor(this.field.w / 2 - surface.size.w / 2),
				y: Math.floor(this.field.h / 2 - surface.size.h / 2)
			});

			surface.setVelocity({
				x: Math.ceil((Math.random() * 3) * (Math.random() > 0.5) ? -1 : 1),
				y: Math.ceil((Math.random() * 3) * (Math.random() > 0.5) ? -1 : 1)
			});

			surface.onClick = function (evt) {
				game.scorePoint();
				game.triggerPlayerChange();
			};

			$("body").append(surface.$node);

			surface.next = this.surfaces;
			this.surfaces = surface;
		};

		/**
		 * Change the name of the current player.  This will reset the player's score, as well as save the player state.
		 * @param {String} name - Player's new name.
		 */

		HappycatGame.prototype.namePlayer = function (name) {
			this.player.name = name;
			this.player.score = 0;
			this.player.save();
			this.triggerPlayerChange();
		};

		/**
		 * Called when a point is scored.  Plays a random sound effect when called, as well as accellerates all surfaces a small amount.
		 */

		HappycatGame.prototype.scorePoint = function () {
			var surfaceTemp = this.surfaces;

			this.player.scorePoint();
			this.soundEffects.playRandom();

			while (surfaceTemp) {
				if (Math.abs(surfaceTemp.velocity.x) <= 20 && Math.abs(surfaceTemp.velocity.y) <= 20) {
					surfaceTemp.accellerate({
						x: Math.floor(Math.random() * 2) * (surfaceTemp.velocity.x < 0) ? -1 : 1,
						y: Math.floor(Math.random() * 2) * (surfaceTemp.velocity.y < 0) ? -1 : 1
					});
				}
				surfaceTemp = surfaceTemp.next;
			}
		};

		/**
		 * Starts the game.  If the player is unknown, then we'll call the introduce() method, if present.  The introduce method should gather necessary information and update the player object state.
		 */

		HappycatGame.prototype.start = function () {
			var game = this;

			if (this.player.isDefaultName()) {
				if (this.introduce) {
					this.introduce();
					return;
				}
			}

			if (!this.timer) {
				this.timer = window.setInterval(
					function () {
						game.iterate();
					},
					16 /* ~ 60fps */
				);
			}
		};

		/**
		 * Resets the game state.  This wipes player information, removes all surfaces from the playing surface, then add a single new surface.
		 */

		HappycatGame.prototype.reset = function () {
			this.pause();
			this.player.wipeSave();
			this.player.load();

			while (this.surfaces) {
				this.surfaces.$node.remove();
				this.surfaces = this.surfaces.next;
			}

			this.addSurface();
		};

		/**
		 * Pauses the game.  Pause has no effect on player or surface state.  It simply stops the game from iterating.
		 */

		HappycatGame.prototype.pause = function () {
			window.clearInterval(this.timer);
			this.timer = null;
		};

		/**
		 * A single iteration of the game.  Invoked approximately 60 times per second.
		 */

		HappycatGame.prototype.iterate = function () {
			var surfaceTemp = this.surfaces;

			while (surfaceTemp) {
				surfaceTemp.iterate(this.field);
				surfaceTemp = surfaceTemp.next;
			}
		};

		HappycatGame.Surface = Surface;
		HappycatGame.Player = Player;

		return {
			HappycatGame: HappycatGame
		};
	}
);


text:
package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net/http/cookiejar"
	"net/url"
	"os"
	"os/signal"
	"strings"

	jira "github.com/andygrunwald/go-jira"
	"golang.org/x/net/publicsuffix"
)

var (
	authStr     = flag.String("a", "", "`username:personal_access_token` combination")
	debugEnable = flag.Bool("D", false, "enable debug output")
	noPlumber   = flag.Bool("p", false, "disable plumber integration and don't linger")
	wrapWidth   = flag.Int("w", 80, "set wrap width")

	debug func(string, ...interface{}) = func(_ string, _ ...interface{}) {}
)

const jiraDateFmt = "2006-01-02T15:04:05.000-0700"

func usage() {
	fmt.Fprintf(os.Stderr, "Usage of %s:\n\n", os.Args[0])
	fmt.Fprintf(os.Stderr, "\t%s [options] server [win]\n\n", os.Args[0])
	flag.PrintDefaults()
	fmt.Fprintf(os.Stderr, "\n")
	fmt.Fprintf(os.Stderr, "Credentials are looked for in a OS-specific secret store (linux only currently),\n")
	fmt.Fprintf(os.Stderr, "then in ~/.jira-creds. The 'a' flag will override both. They're all expected to\n")
	fmt.Fprintf(os.Stderr, "be in the same format.\n\n")
	fmt.Fprintf(os.Stderr, "If a window name is supplied, it will be opened instead of \"my-issues\".\n")
	fmt.Fprintf(os.Stderr, "Some special names include:\n\n")
	fmt.Fprintf(os.Stderr, "\t- my-issues\n")
	fmt.Fprintf(os.Stderr, "\t- search\n")
	fmt.Fprintf(os.Stderr, "\t- filters\n")
	fmt.Fprintf(os.Stderr, "\n")
}

func init() {
	flag.Usage = usage
	log.SetFlags(log.LstdFlags | log.Lshortfile)
}

func main() {
	var auth struct {
		Err  error
		User string
		Pass string
	}
	var err error
	ctx, done := signal.NotifyContext(context.Background(), os.Interrupt, os.Kill)
	defer done()
	flag.Parse()

	if flag.NArg() == 0 {
		log.Fatal("need to specify jira server")
	}
	if *debugEnable {
		debug = func(f string, v ...interface{}) {
			log.Output(2, fmt.Sprintf(f, v...))
		}
	}

	jURL, err := url.Parse(flag.Arg(0))
	if err != nil {
		log.Fatal(err)
	}

	debug("hello")
	// Ideally we'd use some OAuth2 stuff, but it requires server-side setup for some reason.
	auth.User, auth.Pass, auth.Err = secretsOS(ctx, jURL.Host)
	if auth.Err != nil {
		debug("OS secret error: %v", auth.Err)
		auth.User, auth.Pass, auth.Err = secretsFile()
	}
	if *authStr != "" {
		var ok bool
		auth.User, auth.Pass, ok = strings.Cut(*authStr, ":")
		if !ok {
			log.Fatal(fmt.Errorf("unable to make sense of supplied username:password"))
		}
	}

	pat := jira.PATAuthTransport{
		Token: auth.Pass,
	}
	c := pat.Client()
	c.Jar, err = cookiejar.New(&cookiejar.Options{
		PublicSuffixList: publicsuffix.List,
	})
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		return
	}
	j, err := jira.NewClient(c, jURL.String())
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		return
	}

	ui, err := New(strings.TrimSuffix(jURL.Host, ".atlassian.net"), j)
	if err != nil {
		log.Fatal(err)
	}
	if flag.NArg() < 2 {
		ui.look("my-issues")
	} else {
		ui.look(strings.Join(flag.Args()[1:], " "))
	}
	go ui.plumber()

	select {
	case <-ui.exited:
	case <-ctx.Done():
	}
	debug("bye")
}


text:
	/////// //////////////////
	/////// PROJECT: MTA iLife - German Fun Reallife Gamemode
	/////// VERSION: 1.7.2
	/////// DEVELOPERS: See DEVELOPERS.md in the top folder
	/////// LICENSE: See LICENSE.md in the top folder
	/////// /////////////////
]]

--setModelHandling ( 503, "maxVelocity", 10)

local pos={}

load_commands_func = function()
	if(DEFINE_DEBUG) then
		addCommandHandler("int", function (thePlayer,cmd, int)

			if (tonumber(int) == 0) then
				thePlayer:setPosition(pos[thePlayer:getName()]["X"],pos[thePlayer:getName()]["Y"], pos[thePlayer:getName()]["Z"])
				thePlayer:setInterior(0)
				thePlayer:setDimension(0)
			else
				if (thePlayer:getDimension() ~= 0) then

				else
					x,y,z = thePlayer:getPosition()
					pos[thePlayer:getName()]={}
					pos[thePlayer:getName()]["X"] = x
					pos[thePlayer:getName()]["Y"] = y
					pos[thePlayer:getName()]["Z"] = z
				end

				thePlayer:setFrozen(true)
				result = CDatabase:getInstance():query("SELECT * FROM House_Interiors WHERE ID="..tonumber(int))

				local int = result[1]["Int"]
				local x = result[1]["X"]
				local y = result[1]["Y"]
				local z = result[1]["Z"]

				outputChatBox(tostring(result[1]["Int"]).." | "..tostring(result[1]["X"]).." | "..tostring(result[1]["Y"]).." | "..tostring(result[1]["Z"]))

				thePlayer:setInterior(int)
				thePlayer:setPosition(x,y,z)
				thePlayer:setDimension(1)
				thePlayer:setFrozen(false)
			end
		end
		)

		--[[
		addCommandHandler("houseremove", function(thePlayer, cmd, ID)
			local X,Y,Z = thePlayer:getPosition()
			CDatabase:getInstance():query("DELETE FROM Houses WHERE ID=?", tonumber(ID))
			if (Houses[tonumber(ID)]) then
				destroyElement(Houses[tonumber(ID)])
			end
		end
		)]]

		--[[
		addCommandHandler("houseadd", function(thePlayer, cmd, int, cost)
			local X,Y,Z = thePlayer:getPosition()
			CDatabase:getInstance():query("INSERT INTO  `rl`.`Houses` (`ID` , `Cost` , `Owner` , `Koords` , `Locked` , `Interior` ) VALUES ( NULL , ?,  '0', ?,  '0', ?);", tonumber(cost), tostring(thePlayer:getInterior()).."|"..tostring(thePlayer:getDimension()).."|"..tostring(X).."|"..tostring(Y).."|"..tostring(Z),tonumber(int))
			thePickup = createPickup(X,Y,Z, 3, 1273, 1)
			result2 = CDatabase:getInstance():query("SELECT * FROM House_Interiors WHERE ID =?", int)
			enew(thePickup, CHouse, 1337, result2[1]["Price"]+cost, 0, 0,0, toJSON(result2[1]))
			thePickup:setBlip(createBlip(X,Y,Z, 31, 1, 0, 0, 0, 255,0,150, getRootElement()))
		end
		)]]

		addCommandHandler("pos",
		function(thePlayer)
			local i = thePlayer:getInterior()
			local d = thePlayer:getDimension()
			local x,y,z = thePlayer:getPosition()
			local rx, ry, rz = thePlayer:getRotation()
			outputChatBox(tostring(i).."|"..tostring(d).."|"..tostring(x).."|"..tostring(y).."|"..tostring(z).."|"..tostring(rx).."|"..tostring(ry).."|"..tostring(rz))
		end
		)

		addCommandHandler("vpos",
		function(thePlayer)
			local i = thePlayer:getVehicle():getInterior()
			local d = thePlayer:getVehicle():getDimension()
			local x,y,z = thePlayer:getVehicle():getPosition()
			local rx, ry, rz = thePlayer:getVehicle():getRotation()
			outputChatBox(tostring(i).."|"..tostring(d).."|"..tostring(x).."|"..tostring(y).."|"..tostring(z).."|"..tostring(rx).."|"..tostring(ry).."|"..tostring(rz))
		end
		)

		function toggleCursor(thePlayer)
			showCursor(thePlayer, not (isCursorShowing(thePlayer)))
		end

		addCommandHandler("geld", function(uPlayer)
			uPlayer:addMoney(100000)
		end)

		addCommandHandler("hunger", function(tp)
			tp:setHunger(100);
		end)
		addCommandHandler("trash",
		function(thePlayer, cmd)
			local x,y,z = thePlayer:getPosition()
			local int = thePlayer:getInterior()
			local dim = thePlayer:getDimension()

			-- U wot m8??
			-- Das Schlimmste was man in Lua machen kann, MTA Schrott in den Debugtable von der Lua VM Integrieren
		--	_G["Trash"..getPlayerName(thePlayer)] = createObject(1359, x+1,y,z)
			--1549 innen
			--[[
			setElementInterior(_G["Trash"..getPlayerName(thePlayer)], int)
			setElementDimension(_G["Trash"..getPlayerName(thePlayer)], dim)
			setElementCollisionsEnabled(_G["Trash"..getPlayerName(thePlayer)], false)
			attachElements(_G["Trash"..getPlayerName(thePlayer)], thePlayer, 0, 0, -0.35, 0, 0, 0)]]
		end
		)

		addCommandHandler("tadd",
		function(thePlayer, cmd)
			local x,y,z = getElementPosition(_G["Trash"..getPlayerName(thePlayer)])
			local int = getElementInterior(_G["Trash"..getPlayerName(thePlayer)])
			local dim = getElementDimension(_G["Trash"..getPlayerName(thePlayer)])
			local rx,ry,rz = getElementRotation(thePlayer)

			local Kords = int.."|"..dim.."|"..x.."|"..y.."|"..z.."|"..rx.."|"..ry.."|"..rz

			CDatabase:getInstance():query("INSERT INTO `Trashcan` (`ID` ,`Pos`)VALUES (NULL ,  '"..Kords.."');")

			local can = createObject(1359, x,y,z,rx,ry,rz, false)
			enew(can, CTrashcan, #Trashcans+1, Kords)
		end
		)

		addCommandHandler("sound",
		function (thePlayer, cmd, sid)
			playSoundFrontEnd(thePlayer, tonumber(sid))
		end
		)

		addCommandHandler("r", function()
			restartResource(getThisResource())
		end)

		addCommandHandler("garage", function(thePlayer, cmd, gid)
			setGarageOpen(tonumber(gid), not(isGarageOpen(tonumber(gid))))
		end)

		addCommandHandler("hunger", function(thePlayer, cmd, hunger)
			thePlayer:setHunger(tonumber(hunger))
		end)

		addCommandHandler("cam", function(thePlayer, cmd)
			outputChatBox(tostring(getCameraMatrix(thePlayer)))
			local x,y,z,lx,ly,lz,roll,fov = getCameraMatrix(thePlayer)
			outputChatBox(x..","..y..","..z..","..lx..","..ly..","..lz)
		end
		)

		addCommandHandler("ringthatshit", function(player, cmd, ...)
			triggerClientEvent(getRootElement(), "onChurchbellEvent", getRootElement(), ...)
		end)

		addCommandHandler("addInfopickup",
		function(player,cmd,...)
			local parametersTable = {...}
			local stringWithAllParameters = table.concat( parametersTable, " " )
			if stringWithAllParameters ~= nil then
				local x,y,z = getElementPosition(player)
				local int = getElementInterior(player)
				local dim = getElementDimension(player)
				CDatabase:getInstance():query("INSERT INTO `Infopickups`(`X`, `Y`, `Z`, `Int`, `Dim`, `Text`) VALUES (?,?,?,?,?,?)",x,y,z,int,dim,stringWithAllParameters)
				outputChatBox("Info erstellt!",player,0,255,0)

				local infopickup = createPickup(x,y,z,3,1239,0)
				setElementInterior(infopickup,int)
				setElementDimension(infopickup,dim)
				enew(infopickup,CInfoPickup,math.random(15000,100000), x, y, z, int, dim, stringWithAllParameters)
			else
				outputChatBox("Kein Text angegeben!",player,255,0,0)
			end
		end
		)

		addCommandHandler("addDrivein",
		function(player, cmd, theType)
			if ( (tonumber(theType) > 0) and (tonumber(theType)<=5)) then
				local x,y,z = getElementPosition(player)
				CDatabase:getInstance():query("INSERT INTO `DriveIn`(`Type`, `X`, `Y`, `Z`) VALUES (?,?,?,?)", tonumber(theType),x,y,z)
				outputChatBox("Drivein erstellt",player,0,255,0)

				local drivein = createMarker(x, y, z, "corona", 4, 255, 0, 0)
				enew(drivein, CDriveIn, math.random(500,25000000), theType, x, y, z)
			else
				outputChatBox("Bitte Typ angeben!",player,0,255,0)
			end
		end
		)

		addCommandHandler("addNPC",
		function(player)
			local x,y,z = getElementPosition(player)
			local _,_,rz = getElementRotation(player)
			CDatabase:getInstance():query("INSERT INTO `Npc`(`X`, `Y`, `Z`, `Rot`) VALUES (?,?,?,?)",x,y,z,rz)
			outputChatBox("NPC erstellt",player,0,255,0)
			local zahl = math.random(1,6)
			if zahl == 1 then
				local npc = createPed(14,x,y,z,rz)
				enew(npc,CNPC,math.random(500,25000000),x,y,z,rz,zahl)

			elseif zahl == 2 then
				local npc = createPed(28,x,y,z,rz)
				enew(npc,CNPC,math.random(500,25000000),x,y,z,rz,zahl)

			elseif zahl == 3 then
				local npc = createPed(79,x,y,z,rz)
				enew(npc,CNPC,math.random(500,25000000),x,y,z,rz,zahl)

			elseif zahl == 4 then
				local npc = createPed(168,x,y,z,rz)
				enew(npc,CNPC,math.random(500,25000000),x,y,z,rz,zahl)

			elseif zahl == 5 then
				local npc = createPed(135,x,y,z,rz)
				enew(npc,CNPC,math.random(500,25000000),x,y,z,rz,zahl)

			elseif zahl == 6 then
				local npc = createPed(143,x,y,z,rz)
				enew(npc,CNPC,math.random(500,25000000),x,y,z,rz,zahl)

			end
		end
		)

		addCommandHandler("addNoobcar",
		function(player, cmd, model)
			local theVehicle = getPedOccupiedVehicle(player)
			if theVehicle then
				if model then
					local x,y,z = getElementPosition(theVehicle)
					local rx,ry,rz = getElementRotation(theVehicle)
					CDatabase:getInstance():query("INSERT INTO `Noobcars`(`Model`, `X`, `Y`, `Z`,`RX`, `RY`, `RZ`) VALUES (?,?,?,?,?,?,?)", tonumber(model),x,y,z,rx,ry,rz)
					outputChatBox("Noobcar erstellt",player,0,255,0)

					local noobcar = createVehicle(model,x, y, z,rx,ry,rz,"NOOBCAR")
					setElementFrozen(noobcar,true)
					enew(noobcar, CNoobcars, math.random(500,25000000), model, x, y, z,rx,ry,rz)
				else
					outputChatBox("Keine Model ID angegeben!",player,255,0)
				end
			else
				outputChatBox("Du bist in keinem Auto",player,0,255,0)
			end
		end
		)

		addCommandHandler("addParachute",
		function(player)
			local x,y,z = getElementPosition(player)
			CDatabase:getInstance():query("INSERT INTO `Parachutes`(`X`, `Y`, `Z`) VALUES (?,?,?)", x,y,z)
			outputChatBox("Parachute erstellt",player,0,255,0)

			local parachute = createMarker(x,y,z-0.8,"cylinder")
			enew(parachute, CParachute, math.random(500,25000000), x,y,z)
		end
		)
--[[
		addCommandHandler("houseadd", function(thePlayer, cmd, int, cost)
			local X,Y,Z = thePlayer:getPosition()
			CDatabase:getInstance():query("INSERT INTO  `rl`.`Houses` (`ID` , `Cost` , `Owner` , `Koords` , `Locked` , `Interior` ) VALUES ( NULL , ?,  '0', ?,  '0', ?);", tonumber(cost), tostring(thePlayer:getInterior()).."|"..tostring(thePlayer:getDimension()).."|"..tostring(X).."|"..tostring(Y).."|"..tostring(Z),tonumber(int))
			thePickup = createPickup(X,Y,Z, 3, 1273, 1)
			result2 = CDatabase:getInstance():query("SELECT * FROM House_Interiors WHERE ID =?", int)
			enew(thePickup, CHouse, 1337, result2[1]["Price"]+cost, 0, 0,0, toJSON(result2[1]))
			thePickup:setBlip(createBlip(X,Y,Z, 31, 1, 0, 0, 0, 255,0,150, getRootElement()))
		end
		)]]

	end

	addCommandHandler("fveh",
	function(thePlayer, cmd, FID)
		if ((getElementData(thePlayer, "online")) and (thePlayer:getAdminLevel() >= 4)) then
			local veh = thePlayer:getVehicle()
			local x,y,z = veh:getPosition()
			local rx,ry,rz = veh:getRotation()
			local c1,c2,c3,c4,c5,c6 = veh:getColor(true)

			outputChatBox("INSERT INTO  `Faction_Vehicle` (`ID` ,`VID` ,`FID` ,`Int` ,`Dim` ,`Koords` ,`Color` ,`Tuning` ,`KM` ,`Type` ,`Left`)VALUES (NULL ,  '"..veh:getModel().."',  '"..tonumber(FID).."',  '"..veh:getInterior().."',  '"..veh:getDimension().."',  '"..tostring(x).."|"..tostring(y).."|"..tostring(z).."|"..tostring(rx).."|"..tostring(ry).."|"..tostring(rz).."',  '"..tostring(c1).."|"..tostring(c2).."|"..tostring(c3).."|"..tostring(c4).."',  '0|0|0|0|0|0|0',  '0',  '1',  '-1');")
			CDatabase:getInstance():query("INSERT INTO  `Faction_Vehicle` (`ID` ,`VID` ,`FID` ,`Int` ,`Dim` ,`Koords` ,`Color` ,`Tuning` ,`KM` ,`Type` ,`Left`)VALUES (NULL ,  '"..veh:getModel().."',  '"..tonumber(FID).."',  '"..veh:getInterior().."',  '"..veh:getDimension().."',  '"..tostring(x).."|"..tostring(y).."|"..tostring(z).."|"..tostring(rx).."|"..tostring(ry).."|"..tostring(rz).."',  '"..tostring(c1).."|"..tostring(c2).."|"..tostring(c3).."|"..tostring(c4).."|"..tostring(c5).."|"..tostring(c6).."',  '0|0|0|0|0|0|0',  '0',  '1',  '-1');")
		end
	end
	)
end

function createAbsoluteColCuboid(fX, fY, fZ, lX, lY, lZ)
	return createColCuboid(fX,fY,fZ, lX-fX, lY-fY, lZ-fZ)
end

--[[
addCommandHandler("cadd",
	function(thePlayer, cmd, ShopID, Type, Stock, Price)
		local veh = thePlayer:getVehicle()
		local x,y,z = veh:getPosition()
		local rx,ry,rz = veh:getRotation()
		local c1,c2,c3,c4 = veh:getColor(true)

		outputChatBox("INSERT INTO `rl`.`Shop_Vehicle_Data` (`ID`, `VID`, `ShopID`, `Int`, `Dim`, `Koords`, `Color`, `Tuning`, `KM`, `Type`, `Stock`, `Price`) VALUES (NULL, '"..veh:getModel().."', '"..tonumber(ShopID).."', '"..veh:getInterior().."', '"..veh:getDimension().."', '"..tostring(x).."|"..tostring(y).."|"..tostring(z).."|"..tostring(rx).."|"..tostring(ry).."|"..tostring(rz).."', '"..tostring(c1).."|"..tostring(c2).."|"..tostring(c3).."|"..tostring(c4).."', '0|0|0|0|0|0|0', '0', '"..tonumber(Type).."', '"..tonumber(Stock).."', '"..tonumber(Price).."');")
		CDatabase:getInstance():query("INSERT INTO `rl`.`Shop_Vehicle_Data` (`ID`, `VID`, `ShopID`, `Int`, `Dim`, `Koords`, `Color`, `Tuning`, `KM`, `Type`, `Stock`, `Price`) VALUES (NULL, '"..veh:getModel().."', '"..tonumber(ShopID).."', '"..veh:getInterior().."', '"..veh:getDimension().."', '"..tostring(x).."|"..tostring(y).."|"..tostring(z).."|"..tostring(rx).."|"..tostring(ry).."|"..tostring(rz).."', '"..tostring(c1).."|"..tostring(c2).."|"..tostring(c3).."|"..tostring(c4).."', '0|0|0|0|0|0|0', '0', '"..tonumber(Type).."', '"..tonumber(Stock).."', '"..tonumber(Price).."');")
	end
)
]]


text:
package org.ecg.refdata.datasource.entities.commons;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.MappedSuperclass;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

/**
 * Current class extends ReferenceDataAbstractDataTypeEntity and
 * adds couple of additional parameters which contains all dictionary
 * description information for any particular dictionaries types.
 *
 */
@MappedSuperclass
public abstract class ReferenceDataAbstractDataType extends
        ReferenceDataAbstractDataTypeEntity {

    private static final long serialVersionUID = 5424601171276428257L;

    /**
     * @serial Reference data ID field
     *
     * It my opinion it should be unique - DR - as it is not on the diagram we
     * left this open, but consider this at least on ehte database level
     */
    @Column(name = "ref_data_id", length = 20)
    private String refDataId;

    /**
     * @serial Source field
     */
    @Column(name = "source", unique = false, nullable = true, length = 35)
    private String source;

    /**
     * @serial Origin field
     */
    @Column(name = "origin", unique = false, nullable = true, length = 5)
    private String origin;

    /**
     * @serial Item type field
     */
    @Column(name = "item_type", unique = false, nullable = true, length = 35)
    private String itemType;

    /**
     * @serial Item code type field
     */
    @Column(name = "item_code_type", unique = false, nullable = true, length = 6)
    private String itemCodeType;

    /**
     * @serial Publics field
     */
    @Column(name = "publics", unique = false, nullable = true)
    private Boolean publics;

    /**
     * @serial Last change field
     */
    @Column(name = "last_change", unique = false, nullable = true)
    @Temporal(TemporalType.TIMESTAMP)
    private Date lastChange;

    /**
     * Base constructor for all Dictionary types
     *
     * @param itemClass - item type contained by this dictionary
     */
    protected ReferenceDataAbstractDataType(
            Class<? extends ReferenceDataAbstractItemEntity> itemClass) {
        super(itemClass);
    }

    public String getItemCodeType() {
        return itemCodeType;
    }

    public String getItemType() {
        return itemType;
    }

    public Date getLastChange() {
        return lastChange;
    }

    public String getOrigin() {
        return origin;
    }

    public String getSource() {
        return source;
    }

    public String getRefDataId() {
        return refDataId;
    }

    public void setRefDataId(String refDataId) {
        this.refDataId = refDataId;
    }

    public Boolean getPublics() {
        return publics;
    }

    public void setPublics(Boolean publics) {
        this.publics = publics;
    }

    public void setSource(String source) {
        this.source = source;
    }

    public void setOrigin(String origin) {
        this.origin = origin;
    }

    public void setItemType(String itemType) {
        this.itemType = itemType;
    }

    public void setItemCodeType(String itemCodeType) {
        this.itemCodeType = itemCodeType;
    }

    public void setLastChange(Date lastChange) {
        this.lastChange = lastChange;
    }

}


text:
package org.apache.flink.runtime.io.network.partition;

import org.apache.flink.runtime.io.network.api.EndOfPartitionEvent;
import org.apache.flink.runtime.io.network.api.serialization.EventSerializer;
import org.apache.flink.runtime.io.network.buffer.Buffer;
import org.apache.flink.runtime.io.network.buffer.BufferConsumer;

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

import javax.annotation.Nullable;
import javax.annotation.concurrent.GuardedBy;

import java.io.IOException;

import static org.apache.flink.util.Preconditions.checkNotNull;
import static org.apache.flink.util.Preconditions.checkState;

/**
 * A pipelined in-memory only subpartition, which can be consumed once.
 *
 *
Whenever {@link #add(BufferConsumer)} adds a finished {@link BufferConsumer} or a second
 * {@link BufferConsumer} (in which case we will assume the first one finished), we will
 * {@link PipelinedSubpartitionView#notifyDataAvailable() notify} a read view created via
 * {@link #createReadView(BufferAvailabilityListener)} of new data availability. Except by calling
 * {@link #flush()} explicitly, we always only notify when the first finished buffer turns up and
 * then, the reader has to drain the buffers via {@link #pollBuffer()} until its return value shows
 * no more buffers being available. This results in a buffer queue which is either empty or has an
 * unfinished {@link BufferConsumer} left from which the notifications will eventually start again.
 *
 *
Explicit calls to {@link #flush()} will force this
 * {@link PipelinedSubpartitionView#notifyDataAvailable() notification} for any
 * {@link BufferConsumer} present in the queue.
 */
class PipelinedSubpartition extends ResultSubpartition {

	private static final Logger LOG = LoggerFactory.getLogger(PipelinedSubpartition.class);

	// ------------------------------------------------------------------------

	/** The read view to consume this subpartition. */
	private PipelinedSubpartitionView readView;

	/** Flag indicating whether the subpartition has been finished. */
	private boolean isFinished;

	@GuardedBy("buffers")
	private boolean flushRequested;

	/** Flag indicating whether the subpartition has been released. */
	private volatile boolean isReleased;

	// ------------------------------------------------------------------------

	PipelinedSubpartition(int index, ResultPartition parent) {
		super(index, parent);
	}

	@Override
	public boolean add(BufferConsumer bufferConsumer) {
		return add(bufferConsumer, false);
	}

	@Override
	public void finish() throws IOException {
		add(EventSerializer.toBufferConsumer(EndOfPartitionEvent.INSTANCE), true);
		LOG.debug("{}: Finished {}.", parent.getOwningTaskName(), this);
	}

	private boolean add(BufferConsumer bufferConsumer, boolean finish) {
		checkNotNull(bufferConsumer);

		final boolean notifyDataAvailable;
		synchronized (buffers) {
			if (isFinished || isReleased) {
				bufferConsumer.close();
				return false;
			}

			// Add the bufferConsumer and update the stats
			buffers.add(bufferConsumer);
			updateStatistics(bufferConsumer);
			increaseBuffersInBacklog(bufferConsumer);
			notifyDataAvailable = shouldNotifyDataAvailable() || finish;

			isFinished |= finish;
		}

		if (notifyDataAvailable) {
			notifyDataAvailable();
		}

		return true;
	}

	@Override
	public void release() {
		// view reference accessible outside the lock, but assigned inside the locked scope
		final PipelinedSubpartitionView view;

		synchronized (buffers) {
			if (isReleased) {
				return;
			}

			// Release all available buffers
			for (BufferConsumer buffer : buffers) {
				buffer.close();
			}
			buffers.clear();

			view = readView;
			readView = null;

			// Make sure that no further buffers are added to the subpartition
			isReleased = true;
		}

		LOG.debug("{}: Released {}.", parent.getOwningTaskName(), this);

		if (view != null) {
			view.releaseAllResources();
		}
	}

	@Nullable
	BufferAndBacklog pollBuffer() {
		synchronized (buffers) {
			Buffer buffer = null;

			if (buffers.isEmpty()) {
				flushRequested = false;
			}

			while (!buffers.isEmpty()) {
				BufferConsumer bufferConsumer = buffers.peek();

				buffer = bufferConsumer.build();

				checkState(bufferConsumer.isFinished() || buffers.size() == 1,
					"When there are multiple buffers, an unfinished bufferConsumer can not be at the head of the buffers queue.");

				if (buffers.size() == 1) {
					// turn off flushRequested flag if we drained all of the available data
					flushRequested = false;
				}

				if (bufferConsumer.isFinished()) {
					buffers.pop().close();
					decreaseBuffersInBacklogUnsafe(bufferConsumer.isBuffer());
				}

				if (buffer.readableBytes() > 0) {
					break;
				}
				buffer.recycleBuffer();
				buffer = null;
				if (!bufferConsumer.isFinished()) {
					break;
				}
			}

			if (buffer == null) {
				return null;
			}

			updateStatistics(buffer);
			// Do not report last remaining buffer on buffers as available to read (assuming it's unfinished).
			// It will be reported for reading either on flush or when the number of buffers in the queue
			// will be 2 or more.
			return new BufferAndBacklog(
				buffer,
				isAvailableUnsafe(),
				getBuffersInBacklog(),
				nextBufferIsEventUnsafe());
		}
	}

	boolean nextBufferIsEvent() {
		synchronized (buffers) {
			return nextBufferIsEventUnsafe();
		}
	}

	private boolean nextBufferIsEventUnsafe() {
		assert Thread.holdsLock(buffers);

		return !buffers.isEmpty() && !buffers.peekFirst().isBuffer();
	}

	@Override
	public int releaseMemory() {
		// The pipelined subpartition does not react to memory release requests.
		// The buffers will be recycled by the consuming task.
		return 0;
	}

	@Override
	public boolean isReleased() {
		return isReleased;
	}

	@Override
	public PipelinedSubpartitionView createReadView(BufferAvailabilityListener availabilityListener) throws IOException {
		final boolean notifyDataAvailable;
		synchronized (buffers) {
			checkState(!isReleased);
			checkState(readView == null,
					"Subpartition %s of is being (or already has been) consumed, " +
					"but pipelined subpartitions can only be consumed once.", index, parent.getPartitionId());

			LOG.debug("{}: Creating read view for subpartition {} of partition {}.",
				parent.getOwningTaskName(), index, parent.getPartitionId());

			readView = new PipelinedSubpartitionView(this, availabilityListener);
			notifyDataAvailable = !buffers.isEmpty();
		}
		if (notifyDataAvailable) {
			notifyDataAvailable();
		}

		return readView;
	}

	public boolean isAvailable() {
		synchronized (buffers) {
			return isAvailableUnsafe();
		}
	}

	private boolean isAvailableUnsafe() {
		return flushRequested || getNumberOfFinishedBuffers() > 0;
	}

	// ------------------------------------------------------------------------

	int getCurrentNumberOfBuffers() {
		return buffers.size();
	}

	// ------------------------------------------------------------------------

	@Override
	public String toString() {
		final long numBuffers;
		final long numBytes;
		final boolean finished;
		final boolean hasReadView;

		synchronized (buffers) {
			numBuffers = getTotalNumberOfBuffers();
			numBytes = getTotalNumberOfBytes();
			finished = isFinished;
			hasReadView = readView != null;
		}

		return String.format(
			"PipelinedSubpartition#%d [number of buffers: %d (%d bytes), number of buffers in backlog: %d, finished? %s, read view? %s]",
			index, numBuffers, numBytes, getBuffersInBacklog(), finished, hasReadView);
	}

	@Override
	public int unsynchronizedGetNumberOfQueuedBuffers() {
		// since we do not synchronize, the size may actually be lower than 0!
		return Math.max(buffers.size(), 0);
	}

	@Override
	public void flush() {
		final boolean notifyDataAvailable;
		synchronized (buffers) {
			if (buffers.isEmpty()) {
				return;
			}
			// if there is more then 1 buffer, we already notified the reader
			// (at the latest when adding the second buffer)
			notifyDataAvailable = !flushRequested && buffers.size() == 1;
			flushRequested = true;
		}
		if (notifyDataAvailable) {
			notifyDataAvailable();
		}
	}

	private boolean shouldNotifyDataAvailable() {
		// Notify only when we added first finished buffer.
		return readView != null && !flushRequested && getNumberOfFinishedBuffers() == 1;
	}

	private void notifyDataAvailable() {
		if (readView != null) {
			readView.notifyDataAvailable();
		}
	}

	private int getNumberOfFinishedBuffers() {
		assert Thread.holdsLock(buffers);

		// NOTE: isFinished() is not guaranteed to provide the most up-to-date state here
		// worst-case: a single finished buffer sits around until the next flush() call
		// (but we do not offer stronger guarantees anyway)
		if (buffers.size() == 1 && buffers.peekLast().isFinished()) {
			return 1;
		}

		// We assume that only last buffer is not finished.
		return Math.max(0, buffers.size() - 1);
	}
}


text:
# clean-stack [![Build Status](https://travis-ci.org/sindresorhus/clean-stack.svg?branch=master)](https://travis-ci.org/sindresorhus/clean-stack)

> Clean up error stack traces

Removes the mostly unhelpful internal Node.js entries.

Also works in Electron.

## Install

```
$ npm install clean-stack
```

## Usage

```js
const cleanStack = require('clean-stack');

const error = new Error('Missing unicorn');

console.log(error.stack);
/*
Error: Missing unicorn
    at Object.<anonymous> (/Users/sindresorhus/dev/clean-stack/unicorn.js:2:15)
    at Module._compile (module.js:409:26)
    at Object.Module._extensions..js (module.js:416:10)
    at Module.load (module.js:343:32)
    at Function.Module._load (module.js:300:12)
    at Function.Module.runMain (module.js:441:10)
    at startup (node.js:139:18)
*/

console.log(cleanStack(error.stack));
/*
Error: Missing unicorn
    at Object.<anonymous> (/Users/sindresorhus/dev/clean-stack/unicorn.js:2:15)
*/
```

## API

### cleanStack(stack, [options])

#### stack

Type: `string`

The `stack` property of an `Error`.

#### options

Type: `Object`

##### pretty

Type: `boolean`<br>
Default: `false`

Prettify the file paths in the stack:

`/Users/sindresorhus/dev/clean-stack/unicorn.js:2:15` → `~/dev/clean-stack/unicorn.js:2:15`

## Related

- [extrack-stack](https://github.com/sindresorhus/extract-stack) - Extract the actual stack of an error
- [stack-utils](https://github.com/tapjs/stack-utils) - Captures and cleans stack traces

## License

MIT © [Sindre Sorhus](https://sindresorhus.com)


text:
"""
Test data builders for text XML elements
"""

from ...unitdata import BaseBuilder
from .shared import CT_OnOffBuilder, CT_StringBuilder

class CT_BrBuilder(BaseBuilder):
    __tag__ = 'w:br'
    __nspfxs__ = ('w',)
    __attrs__ = ('w:type', 'w:clear')

class CT_PBuilder(BaseBuilder):
    __tag__ = 'w:p'
    __nspfxs__ = ('w',)
    __attrs__ = ()

class CT_PPrBuilder(BaseBuilder):
    __tag__ = 'w:pPr'
    __nspfxs__ = ('w',)
    __attrs__ = ()

class CT_RBuilder(BaseBuilder):
    __tag__ = 'w:r'
    __nspfxs__ = ('w',)
    __attrs__ = ()

class CT_RPrBuilder(BaseBuilder):
    __tag__ = 'w:rPr'
    __nspfxs__ = ('w',)
    __attrs__ = ()

class CT_SectPrBuilder(BaseBuilder):
    __tag__ = 'w:sectPr'
    __nspfxs__ = ('w',)
    __attrs__ = ()

class CT_TextBuilder(BaseBuilder):
    __tag__ = 'w:t'
    __nspfxs__ = ('w',)
    __attrs__ = ()

    def with_space(self, value):
        self._set_xmlattr('xml:space', str(value))
        return self

def a_b():
    return CT_OnOffBuilder('w:b')

def a_bCs():
    return CT_OnOffBuilder('w:bCs')

def a_br():
    return CT_BrBuilder()

def a_caps():
    return CT_OnOffBuilder('w:caps')

def a_cs():
    return CT_OnOffBuilder('w:cs')

def a_dstrike():
    return CT_OnOffBuilder('w:dstrike')

def a_noProof():
    return CT_OnOffBuilder('w:noProof')

def a_shadow():
    return CT_OnOffBuilder('w:shadow')

def a_smallCaps():
    return CT_OnOffBuilder('w:smallCaps')

def a_snapToGrid():
    return CT_OnOffBuilder('w:snapToGrid')

def a_specVanish():
    return CT_OnOffBuilder('w:specVanish')

def a_strike():
    return CT_OnOffBuilder('w:strike')

def a_vanish():
    return CT_OnOffBuilder('w:vanish')

def a_webHidden():
    return CT_OnOffBuilder('w:webHidden')

def a_p():
    return CT_PBuilder()

def a_pPr():
    return CT_PPrBuilder()

def a_pStyle():
    return CT_StringBuilder('w:pStyle')

def a_sectPr():
    return CT_SectPrBuilder()

def a_t():
    return CT_TextBuilder()

def an_emboss():
    return CT_OnOffBuilder('w:emboss')

def an_i():
    return CT_OnOffBuilder('w:i')

def an_iCs():
    return CT_OnOffBuilder('w:iCs')

def an_imprint():
    return CT_OnOffBuilder('w:imprint')

def an_oMath():
    return CT_OnOffBuilder('w:oMath')

def an_outline():
    return CT_OnOffBuilder('w:outline')

def an_r():
    return CT_RBuilder()

def an_rPr():
    return CT_RPrBuilder()

def an_rtl():
    return CT_OnOffBuilder('w:rtl')


text:
/* Paned Widgets
 *
 * The GtkHPaned and GtkVPaned Widgets divide their content
 * area into two panes with a divider in between that the
 * user can adjust. A separate child is placed into each
 * pane.
 *
 * There are a number of options that can be set for each pane.
 * This test contains both a horizontal (HPaned) and a vertical
 * (VPaned) widget, and allows you to adjust the options for
 * each side of each widget.
 */

#include <gtkmm.h>

namespace
{

class Example_Panes : public Gtk::Window
{
public:
  Example_Panes();
  virtual ~Example_Panes();
};

class PaneOptions : public Gtk::Frame
{
public:
  PaneOptions(Gtk::Paned& paned, const Glib::ustring& frame_label,
              const Glib::ustring& label1, const Glib::ustring& label2);
  virtual ~PaneOptions();

private:
  // member widgets:
  Gtk::Paned*      m_pPaned;
  Gtk::CheckButton m_CheckButton_resize1;
  Gtk::CheckButton m_CheckButton_shrink1;
  Gtk::CheckButton m_CheckButton_resize2;
  Gtk::CheckButton m_CheckButton_shrink2;

  // signal handlers:
  void on_checkbutton1();
  void on_checkbutton2();
};

Example_Panes::Example_Panes()
{
  set_title("Panes");
  set_border_width(0);

  Gtk::Box *const pVBox = new Gtk::Box(Gtk::ORIENTATION_VERTICAL);
  add(*Gtk::manage(pVBox));

  Gtk::Paned *const pVPaned = new Gtk::Paned(Gtk::ORIENTATION_VERTICAL);
  pVBox->pack_start(*Gtk::manage(pVPaned));
  pVPaned->set_border_width(5);

  Gtk::Paned *const pHPaned = new Gtk::Paned(Gtk::ORIENTATION_HORIZONTAL);
  pVPaned->add1(*Gtk::manage(pHPaned));

  Gtk::Frame *const pFrame1 = new Gtk::Frame();
  pHPaned->add1(*Gtk::manage(pFrame1));
  pFrame1->set_shadow_type(Gtk::SHADOW_IN);
  pFrame1->set_size_request(60, 60);
  pFrame1->add(*Gtk::manage(new Gtk::Button("_Hi there", true)));

  Gtk::Frame *const pFrame2 = new Gtk::Frame();
  pHPaned->add2(*Gtk::manage(pFrame2));
  pFrame2->set_shadow_type(Gtk::SHADOW_IN);
  pFrame2->set_size_request(80, 60);

  Gtk::Frame *const pFrame3 = new Gtk::Frame();
  pVPaned->add2(*Gtk::manage(pFrame3));
  pFrame3->set_shadow_type(Gtk::SHADOW_IN);
  pFrame3->set_size_request(60, 80);

  // Now create check buttons to control sizing
  pVBox->pack_start(*Gtk::manage(new PaneOptions(*pHPaned, "Horizontal", "Left", "Right")), Gtk::PACK_SHRINK);
  pVBox->pack_start(*Gtk::manage(new PaneOptions(*pVPaned, "Vertical", "Top", "Bottom")),   Gtk::PACK_SHRINK);

  show_all();
}

Example_Panes::~Example_Panes()
{}

PaneOptions::PaneOptions(Gtk::Paned& paned, const Glib::ustring& frame_label,
                         const Glib::ustring& label1, const Glib::ustring& label2)
:
  Gtk::Frame            (frame_label),
  m_pPaned              (&paned),
  m_CheckButton_resize1 ("_Resize", true),
  m_CheckButton_shrink1 ("_Shrink", true),
  m_CheckButton_resize2 ("_Resize", true),
  m_CheckButton_shrink2 ("_Shrink", true)
{
  set_border_width(4);

  Gtk::Grid *const pGrid = new Gtk::Grid();
  add(*Gtk::manage(pGrid));

  pGrid->attach(*Gtk::manage(new Gtk::Label(label1)), 0, 0, 1, 1);
  pGrid->attach(*Gtk::manage(new Gtk::Label(label2)), 1, 0, 1, 1);

  pGrid->attach(m_CheckButton_resize1, 0, 1, 1, 1);
  pGrid->attach(m_CheckButton_shrink1, 0, 2, 1, 1);
  pGrid->attach(m_CheckButton_resize2, 1, 1, 1, 1);
  pGrid->attach(m_CheckButton_shrink2, 1, 2, 1, 1);

  m_CheckButton_resize1.set_active(false);
  m_CheckButton_shrink1.set_active(true);
  m_CheckButton_resize2.set_active(true);
  m_CheckButton_shrink2.set_active(true);

  m_CheckButton_resize1.signal_toggled().connect(sigc::mem_fun(*this, &PaneOptions::on_checkbutton1));
  m_CheckButton_shrink1.signal_toggled().connect(sigc::mem_fun(*this, &PaneOptions::on_checkbutton1));
  m_CheckButton_resize2.signal_toggled().connect(sigc::mem_fun(*this, &PaneOptions::on_checkbutton2));
  m_CheckButton_shrink2.signal_toggled().connect(sigc::mem_fun(*this, &PaneOptions::on_checkbutton2));

  // Sync Gtk::Paned options with the CheckButtons' state.  Actually, the
  // preset state of the buttons should match the Gtk::Paned default settings,
  // but it is definitely cleaner this way.
  on_checkbutton1();
  on_checkbutton2();
}

PaneOptions::~PaneOptions()
{}

void PaneOptions::on_checkbutton1()
{
  Gtk::AttachOptions options = Gtk::AttachOptions(0);

  if(m_CheckButton_resize1.get_active()) options = (options | Gtk::EXPAND);
  if(m_CheckButton_shrink1.get_active()) options = (options | Gtk::SHRINK);

  Gtk::Widget *const pChild = m_pPaned->get_child1();

  m_pPaned->remove(*pChild);
  m_pPaned->pack1(*pChild, options);
}

void PaneOptions::on_checkbutton2()
{
  Gtk::AttachOptions options = Gtk::AttachOptions(0);

  if(m_CheckButton_resize2.get_active()) options = (options | Gtk::EXPAND);
  if(m_CheckButton_shrink2.get_active()) options = (options | Gtk::SHRINK);

  Gtk::Widget *const pChild = m_pPaned->get_child2();

  m_pPaned->remove(*pChild);
  m_pPaned->pack2(*pChild, options);
}

} // anonymous namespace

// called by DemoWindow
Gtk::Window* do_panes()
{
  return new Example_Panes();
}


text:
ida-scripts
===========

IDA scripts


text:
struct llist_t *create_llist_member(void)
{
    struct llist_t *a = (struct llist_t*)malloc(sizeof(struct llist_t));
    return a;
};

struct llist_t* append_ll_item(struct llist_t *head,void *a)
{
    struct llist_t *ll = create_llist_member();
    if (head == NULL) {
        //if no head exists, a is head
        ll->ptr = a;
        ll->next = NULL;
        ll->prev = NULL;
        return ll;
    } else {
        struct llist_t *cursor = head;
        //go to last node
        while(cursor->next != NULL)
            cursor = cursor->next;

        //add the node to the last node
        ll->ptr = a;
        ll->next = NULL;
        cursor->next = ll;
        ll->prev = cursor;
        return head;
    }
}

struct llist_t* prepend_ll_item(struct llist_t *head,void *a)
{
    struct llist_t *ll = create_llist_member();
    if (head == NULL){
        //if no head exists, a is head
        ll->ptr = a;
        ll->next = NULL;
        ll->prev = NULL;
        return ll;
    } else {
        ll->ptr = a;
        ll->next = head;
        ll->prev = NULL;
        head->prev = ll;
        return ll;
    }
}

void free_llist_item(void *a)
{
    struct enemy_t *enemy;
    struct tower_t *tower;
    struct float_text_t *float_text;
    //first item in any llist struct is int id!
    int *id_ptr,id;
    //void pointer to integer pointer
    id_ptr = a;
    //get integer value
    id = *id_ptr;
    //determine struct from this id
    switch(id){
        case(LLIST_ENEMY):
            enemy = a;
            free(enemy);
            break;
        case(LLIST_TOWER):
            tower = a;
            free(tower);
            break;
        case(LLIST_FLOAT_TEXT):
            float_text = a;
            free(float_text);
            break;
        default:
            break;
    }

}

struct llist_t* remove_ll_item(struct llist_t *head,struct llist_t *ll,void (*free_struct)(void *))
{
    if (head != NULL){
        struct llist_t *cursor;
        //if head
        if (head == ll){
            cursor = head;
            head = head->next;
            free_struct(ll->ptr);
            free(ll);

        //if last and not only one because of previous condition
        } else if (ll->next == NULL){
            cursor = ll->prev;
            cursor->next = NULL;
            free_struct(ll->ptr);
            free(ll);

        //if in the middle
        } else {
            //previous node
            cursor = ll->prev;
            cursor->next = ll->next;
            //next node
            cursor = ll->next;
            cursor->prev = ll->prev;
            free_struct(ll->ptr);
            free(ll);
        }
    }
    return head;
}

//ENEMY
struct enemy_t* create_enemy(int x, int y, int path_start, float speed, float health, int credits)
{
    struct enemy_t *a = (struct enemy_t*)malloc(sizeof(struct enemy_t));
    a->position.x = x;
    a->position.y = y;
    a->path_num = path_start;
    a->speed = speed;
    a->max_health = health;
    a->health = health;
    a->credits = credits;

    return a;
}

void free_enemy_t (void *a)
{
    struct enemy_t *b = a;
    free(b);
}

//TRAINS
struct train_t* create_train_unit(bool visible, int x, int y, int path_start, bool loco, int direction, float speed, float health, int credits)
{
    struct train_t *a = (struct train_t*)malloc(sizeof(struct train_t));
    a->visible = visible;
    a->position.x = x;
    a->position.y = y;
    a->angle = 0;
    a->path_num = path_start;
    a->locomotive = loco;
    a->direction = direction;
    a->speed = speed;
    a->max_health = health;
    a->health = health;
    a->credits = credits;
    a->prew_train = NULL;
    a->next_train = NULL;

    return a;
}

void free_train_t (void *a)
{
    struct train_t *b = a;
    free(b);
}

//TOWERS
struct tower_t* create_tower(int x, int y, float angle, float damage, int level, float range, int price)
{
    struct tower_t *a = (struct tower_t*)malloc(sizeof(struct tower_t));
    a->position.x = x;
    a->position.y = y;
    a->angle = angle;
    a->damage = damage;
    a->fire_active = false;
    a->level = level;
    a->range = range;
    a->price = price;
    a->e_target = NULL;
    a->t_target = NULL;

    return a;
}

void free_tower_t (void *a)
{
    struct tower_t *b = a;
    free(b);
}

//FLOATING TEXT
struct float_text_t* create_float_text(int x, int y, int move_per_tick, int timeout, char text[], ALLEGRO_COLOR colour)
{
    struct float_text_t *a = (struct float_text_t*)malloc(sizeof(struct float_text_t));
    a->x = x;
    a->y = y;
    a->move_per_tick = move_per_tick;
    a->timeout = timeout;
    strcpy(a->text, text);
    a->colour = colour;

    return a;
}

void free_float_text_t (void *a)
{
    struct float_text_t *b = a;
    free(b);
}


text:
package br.com.objectos.jabuticava.cnab.remessa;

import br.com.objectos.jabuticava.cnab.remessa.AgenciaBuilder;
import br.com.objectos.jabuticava.cnab.remessa.AgenciaBuilderPojo;
import br.com.objectos.way.pojo.Pojo;

/**
 * @author marcio.endo@objectos.com.br (Marcio Endo)
 */
@Pojo
public abstract class Agencia {

  public abstract int getCodigo();
  public abstract int getDigito();

  protected Agencia() {
  }

  public static AgenciaBuilder builder() {
    return new AgenciaBuilderPojo();
  }

}


text:
require 'rails_helper'

RSpec.describe "circles/show", type: :view do
  before(:each) do
    @circle = assign(:circle, Circle.create!(
      :name => "Name"
    ))
  end

  it "renders attributes in <p>" do
    render
    expect(rendered).to match(/Name/)
  end
end


text:
\hypertarget{class_tile}{}\doxysection{Tile Class Reference}
\label{class_tile}\index{Tile@{Tile}}

{\ttfamily \#include $<$Tile.\+h$>$}

\doxysubsection*{Public Member Functions}
\begin{DoxyCompactItemize}
\item
int \mbox{\hyperlink{class_tile_ac382874a902694c3ce05c84b5d0f6731}{get\+Id}} () const
\item
bool \mbox{\hyperlink{class_tile_a2f9971efdf7b36249a491ca7ceb2ef57}{is\+Walkable}} () const
\item
\mbox{\Hypertarget{class_tile_aaea2c49c1fb9e2984561ad2c81030ce1}\label{class_tile_aaea2c49c1fb9e2984561ad2c81030ce1}}
void {\bfseries set\+Id} (int new\+Id)
\item
\mbox{\Hypertarget{class_tile_a8d63f5d2e5408e2c5f9570c10cb4c835}\label{class_tile_a8d63f5d2e5408e2c5f9570c10cb4c835}}
void {\bfseries set\+Walkable} (bool can\+Walk)
\item
\mbox{\Hypertarget{class_tile_a723735775252ec1206a5eb53b32873b1}\label{class_tile_a723735775252ec1206a5eb53b32873b1}}
void {\bfseries increment\+Id} ()
\item
\mbox{\Hypertarget{class_tile_a3d375cc6ae55d3ccf7bad4d746cfbe58}\label{class_tile_a3d375cc6ae55d3ccf7bad4d746cfbe58}}
void {\bfseries decrement\+Id} ()
\end{DoxyCompactItemize}

\doxysubsection{Detailed Description}
A tile object represents a map tile. It has information about the tile id and whether the tile is walkable. The \mbox{\hyperlink{class_tile}{Tile}} object has nothing to do with tile images.

\doxysubsection{Member Function Documentation}
\mbox{\Hypertarget{class_tile_ac382874a902694c3ce05c84b5d0f6731}\label{class_tile_ac382874a902694c3ce05c84b5d0f6731}}
\index{Tile@{Tile}!getId@{getId}}
\index{getId@{getId}!Tile@{Tile}}
\doxysubsubsection{\texorpdfstring{getId()}{getId()}}
{\footnotesize\ttfamily int Tile\+::get\+Id (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption}) const}

\begin{DoxyReturn}{Returns}
the tile id. Useful to determine which part of the tileset to extract.
\end{DoxyReturn}
\mbox{\Hypertarget{class_tile_a2f9971efdf7b36249a491ca7ceb2ef57}\label{class_tile_a2f9971efdf7b36249a491ca7ceb2ef57}}
\index{Tile@{Tile}!isWalkable@{isWalkable}}
\index{isWalkable@{isWalkable}!Tile@{Tile}}
\doxysubsubsection{\texorpdfstring{isWalkable()}{isWalkable()}}
{\footnotesize\ttfamily bool Tile\+::is\+Walkable (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption}) const}

Returns whether the tile is walkable

The documentation for this class was generated from the following files\+:\begin{DoxyCompactItemize}
\item
\mbox{\hyperlink{_tile_8h}{Tile.\+h}}\item
Tile.\+cpp\end{DoxyCompactItemize}