text:
package no.noen.server.lms;

import java.util.ArrayList;
import java.util.List;
import no.noen.lms.*;
import org.komsa.log.LogWriter;
import org.komsa.server.entity.EntityFactory;
import org.komsa.server.entity.ListFactory;
import org.komsa.xdoc.query.*;

/**
 * LMS load entity factory.
 */
public class LoadFactory {
    /** Name of database schema. */
    private static final String SCHEMA = "lms";

    /** Default constructor. */
    protected LoadFactory() {
    }

    /**
     * Get list of messages.
     * @return List with SwitchMessage objects.
     */
    public static List<SwitchMessage> getMessages() {
        List<SwitchMessage> list = new ArrayList<SwitchMessage>();
        try {
            ListFactory fac = new ListFactory(SCHEMA, "SwitchMessage");
            fac.orderBy("brym.status");
            fac.orderBy("brym.startTid", SortMetaData.SORT_DESC);
            fac.load(list);
        } catch (Exception ex) {
            LogWriter.elog(ex, "LoadFactory.getMessages");
        }
        return list;
    }

    /**
     * Get list of messages for a LoadProduct, not including failed messages.
     * @param productId LoadProduct ID
     * @param startTime Start date
     * @return List with SwitchMessage objects.
     */
    public static List<SwitchMessage> getProductMessages(long productId, java.util.Date startTime) {
        List<SwitchMessage> list = new ArrayList<SwitchMessage>();
        try {
            ListFactory fac = new ListFactory(SCHEMA, "SwitchMessage");
            fac.addFilter("brym.lprodId", productId);
            fac.addFilter(new FilterMetaData("brym.status",
                "" + SwitchMessage.STATUS_FAILED, Operators.OP_NOTEQUALTO));
            java.sql.Timestamp ts = new java.sql.Timestamp(startTime.getTime());
            fac.addFilter(new FilterMetaData("brym.startTid", "" + ts.toString(),
                                             Operators.OP_GREATER));
            fac.orderBy("brym.status");
            fac.orderBy("brym.startTid", SortMetaData.SORT_DESC);
            fac.load(list);
        } catch (Exception ex) {
            LogWriter.elog(ex, "LoadFactory.getProductMessages " + productId);
        }
        return list;
    }

    /**
     * Get instance of SwitchMessage with a given ID.
     * @param id Message ID
     * @return SwitchMessage object or null if not found.
     */
    public static SwitchMessage getMessage(String id) {
        EntityFactory efac = new EntityFactory();
        return (SwitchMessage)efac.getEntity(SCHEMA, "SwitchMessage", id);
    }

    /**
     * Get list of messages with group ref.
     * @param loadId LoadGroup ID
     * @return List with GroupActivation objects.
     */
    public static List<GroupActivation> getGroupActivations(long loadId) {
        List<SwitchMessage> messages = new ArrayList<SwitchMessage>();
        try {
            ListFactory fac = new ListFactory(SCHEMA, "SwitchMessage");
            fac.addFilter("brym.lastgId", loadId);
            fac.addFilter(new FilterMetaData("brym.gruppeId", "0",
                                             Operators.OP_GREATER));
            fac.orderBy("brym.gruppeId", SortMetaData.SORT_DESC);
            fac.orderBy("brym.status", SortMetaData.SORT_ASC);
            fac.orderBy("brym.startTid", SortMetaData.SORT_DESC);
            fac.load(messages);
        } catch (Exception ex) {
            LogWriter.elog(ex, "LoadFactory.getGroupActivations");
        }
        return createGroupActivations(messages);
    }

    /**
     * Get list of messages for a contract group.
     * @param cgroup Contract group / super-group
     * @return List with GroupActivation objects.
     */
    public static List<GroupActivation> getSuperGroupActivations(ContractGroup cgroup) {
        List<SwitchMessage> messages = new ArrayList<SwitchMessage>();
        FilterMetaData fmd = new FilterMetaData("brym.lastgId");
        fmd.setOperator(Operators.OP_IN);
        for (int i = 0, n = cgroup.getElementCount(); i < n; i++) {
            SuperGroupElement elem = cgroup.getElement(i);
            fmd.addValue("" + elem.getGroupId());
        }
        try {
            ListFactory fac = new ListFactory(SCHEMA, "SwitchMessage");
            fac.addFilter(fmd);
            fac.addFilter(new FilterMetaData("brym.gruppeId", "0",
                                             Operators.OP_GREATER));
            fac.orderBy("brym.gruppeId", SortMetaData.SORT_DESC);
            fac.orderBy("brym.status", SortMetaData.SORT_ASC);
            fac.orderBy("brym.startTid", SortMetaData.SORT_DESC);
            fac.load(messages);
        } catch (Exception ex) {
            LogWriter.elog(ex, "LoadFactory.getSuperGroupActivations");
        }
        return createGroupActivations(messages);
    }

    /**
     * @param messages List of SwitchMessage objects
     * @return List with GroupActivation objects.
     */
    protected static List<GroupActivation> createGroupActivations(List<SwitchMessage> messages) {
        long groupId = 0;
        ContractFactory cfac = new ContractFactory();
        GroupActivation groupAct = null;
        List<GroupActivation> list = new ArrayList<GroupActivation>();
        for (int i = 0, n = messages.size(); i < n; i++) {
            SwitchMessage msg = messages.get(i);
            long gID = msg.getGroupID();
            if (gID != groupId) {
                groupId = gID;
                if (groupAct != null)
                    list.add(groupAct);
                LoadGroup lg = cfac.getLoadGroup("" + msg.getLoadId());
                groupAct = new GroupActivation(groupId, lg);
            }
            groupAct.addMessage(msg);
        }
        // Add last load in list
        if (groupAct != null)
            list.add(groupAct);
        return list;
    }

    /**
     * Get a GroupActivation, with list of messages for a group.
     * @param groupId Group ID
     * @return GroupActivation object or null if not found.
     */
    public static GroupActivation getGroupActivation(long groupId) {
        List<SwitchMessage> messages = new ArrayList<SwitchMessage>();
        try {
            ListFactory fac = new ListFactory(SCHEMA, "SwitchMessage");
            fac.addFilter("brym.gruppeId", groupId);
            fac.orderBy("brym.status", SortMetaData.SORT_ASC);
            fac.orderBy("brym.startTid", SortMetaData.SORT_DESC);
            fac.load(messages);
        } catch (Exception ex) {
            LogWriter.elog(ex, "LoadFactory.getActiveLoad " + groupId);
        }
        GroupActivation al = null;
        if (messages.size() > 0) {
            for (int i = 0, n = messages.size(); i < n; i++) {
                SwitchMessage msg = messages.get(i);
                if (al == null) {
                    ContractFactory cfac = new ContractFactory();
                    LoadGroup loadGroup = cfac.getLoadGroup("" + msg.getLoadId());
                    if (loadGroup != null)
                        al = new GroupActivation(groupId, loadGroup);
                }
                al.addMessage(msg);
            }
        }
        return al;
    }

    /**
     * Get GroupDayData for a load-group in a period.
     * @param loadId Load group ID
     * @param startDate Start date
     * @param endDate End date
     * @return List of GroupDayData objects.
     */
    public static List<GroupDayData> listGroupDayData(long loadId, java.util.Date startDate, java.util.Date endDate) {
        List<GroupDayData> list = new ArrayList<GroupDayData>();
        try {
            ListFactory fac = new ListFactory(SCHEMA, "GroupDayData");
            fac.addFilter("lprod.lastgId", loadId);
            java.sql.Date date1 = new java.sql.Date(startDate.getTime());
            java.sql.Date date2 = new java.sql.Date(endDate.getTime());
            fac.addFilter(
                new FilterMetaData("edat.dato", date1.toString(),
                                   date2.toString(), Operators.OP_BETWEEN));
            fac.load(list);
        } catch (Exception ex) {
            LogWriter.elog(ex, "LoadFactory.getGroupDayData: load=" + loadId);
        }
        return list;
    }

    /**
     * Get GroupDayData for a date and a load-group.
     * @param loadId Load group ID
     * @param date Date
     * @return GroupDayData object or null if not found.
     */
    public static GroupDayData getGroupDayData(long loadId, java.util.Date date) {
        GroupDayData dayData = null;
        try {
            java.sql.Date date1 = new java.sql.Date(date.getTime());
            FilterMetaData[] filters = {
                new FilterMetaData("lprod.lastgId", "" + loadId),
                new FilterMetaData("edat.dato", date1.toString())
            };
            EntityFactory efac = new EntityFactory();
            dayData = (GroupDayData)efac.findEntity(SCHEMA, "GroupDayData", filters);
        } catch (Exception ex) {
            LogWriter.elog(ex, "LoadFactory.getGroupDayData: load=" + loadId);
        }
        return dayData;
    }

}


text:
<!DOCTYPE html>

    <title>Mayank Badola</title>
    <meta name="description" content="ASDE at Expedia. Technology Enthusiast. Occasional Philosopher.">
    <meta name="keywords" content="Mayank Badola, mayank badola, mayank, mbad0la, github, GitHub, NSIT, Netaji Subhas Institute of Technology, Developer, Web Developer, Software Developer, JavaScript Developer, Software Engineer, Open Source, DuckDuckGo, Fossasia, Hoodie, Mozpacers, ODIN, Open Development Initiative - NSIT, Collegespace, Machine Learning, Big Data, Udacity, Udacity India, Expedia, ASDE, The Air Force School, TAFS, TAFSian">
    <meta itemprop="image" content="http://mayankbadola.me/media/me.jpg">
    <meta name="twitter:card" content="summary">
    <meta name="twitter:site" content="@mbad0la">
    <meta name="twitter:title" content="Mayank Badola">
    <meta name="twitter:description" content="ASDE at Expedia. Technology Enthusiast. Occasional Philosopher.">
    <meta property="og:type" content="article">
    <meta property="og:title" content="Mayank Badola">
    <meta property="og:description" content="ASDE at Expedia. Technology Enthusiast. Occasional Philosopher.">
    <meta property="og:site_name" content="Mayank Badola">
    <meta property="og:url" content="http://mayankbadola.me">
    <meta property="og:image" content="http://mayankbadola.me/media/me.jpg">
    <meta property="article:author" content="https://facebook.com/mbad0la">
    <link rel="icon" href="/media/favicon.png" type="image/x-icon">
    <link rel="manifest" href="/manifest.json">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link href="https://fonts.googleapis.com/css?family=Roboto+Slab|Gloria+Hallelujah|Open+Sans" rel="stylesheet">
    <link rel="stylesheet" href="/css/website.css" />

redpajama_set_name: RedPajamaGithub


text:
package org.jboss.arquillian.persistence.dbunit.filter;

import org.dbunit.database.DatabaseSequenceFilter;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.dataset.DataSetException;
import org.jboss.arquillian.persistence.dbunit.DataSetUtils;

import java.sql.SQLException;

public class OracleDatabaseSequenceFilter extends DatabaseSequenceFilter {

    public OracleDatabaseSequenceFilter(IDatabaseConnection connection, String[] tableNames) throws DataSetException, SQLException {
        super(connection, DataSetUtils.tableNamesInUpperCase(tableNames));
    }

    public OracleDatabaseSequenceFilter(IDatabaseConnection connection) throws DataSetException, SQLException {
        super(connection);
    }
}


text:
#include "config.h"
#include "modules/webdatabase/DatabaseTask.h"

#include "platform/Logging.h"
#include "modules/webdatabase/Database.h"
#include "modules/webdatabase/DatabaseContext.h"
#include "modules/webdatabase/DatabaseThread.h"

namespace WebCore {

DatabaseTaskSynchronizer::DatabaseTaskSynchronizer()
    : m_taskCompleted(false)
#ifndef NDEBUG
    , m_hasCheckedForTermination(false)
#endif
{
}

void DatabaseTaskSynchronizer::waitForTaskCompletion()
{
    m_synchronousMutex.lock();
    while (!m_taskCompleted)
        m_synchronousCondition.wait(m_synchronousMutex);
    m_synchronousMutex.unlock();
}

void DatabaseTaskSynchronizer::taskCompleted()
{
    m_synchronousMutex.lock();
    m_taskCompleted = true;
    m_synchronousCondition.signal();
    m_synchronousMutex.unlock();
}

DatabaseTask::DatabaseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
    : m_database(database)
    , m_synchronizer(synchronizer)
#if !LOG_DISABLED
    , m_complete(false)
#endif
{
}

DatabaseTask::~DatabaseTask()
{
#if !LOG_DISABLED
    ASSERT(m_complete || !m_synchronizer);
#endif
}

void DatabaseTask::run()
{
    // Database tasks are meant to be used only once, so make sure this one hasn't been performed before.
#if !LOG_DISABLED
    ASSERT(!m_complete);
#endif

    if (!m_synchronizer && !m_database->databaseContext()->databaseThread()->isDatabaseOpen(m_database.get())) {
        taskCancelled();
#if !LOG_DISABLED
        m_complete = true;
#endif
        return;
    }

    WTF_LOG(StorageAPI, "Performing %s %p\n", debugTaskName(), this);

    m_database->resetAuthorizer();
    doPerformTask();

    if (m_synchronizer)
        m_synchronizer->taskCompleted();

#if !LOG_DISABLED
    m_complete = true;
#endif
}

// *** DatabaseOpenTask ***
// Opens the database file and verifies the version matches the expected version.

DatabaseBackend::DatabaseOpenTask::DatabaseOpenTask(DatabaseBackend* database, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
    : DatabaseTask(database, synchronizer)
    , m_setVersionInNewDatabase(setVersionInNewDatabase)
    , m_error(error)
    , m_errorMessage(errorMessage)
    , m_success(success)
{
    ASSERT(synchronizer); // A task with output parameters is supposed to be synchronous.
}

void DatabaseBackend::DatabaseOpenTask::doPerformTask()
{
    String errorMessage;
    m_success = database()->performOpenAndVerify(m_setVersionInNewDatabase, m_error, errorMessage);
    if (!m_success)
        m_errorMessage = errorMessage.isolatedCopy();
}

#if !LOG_DISABLED
const char* DatabaseBackend::DatabaseOpenTask::debugTaskName() const
{
    return "DatabaseOpenTask";
}
#endif

// *** DatabaseCloseTask ***
// Closes the database.

DatabaseBackend::DatabaseCloseTask::DatabaseCloseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
    : DatabaseTask(database, synchronizer)
{
}

void DatabaseBackend::DatabaseCloseTask::doPerformTask()
{
    Database::from(database())->close();
}

#if !LOG_DISABLED
const char* DatabaseBackend::DatabaseCloseTask::debugTaskName() const
{
    return "DatabaseCloseTask";
}
#endif

// *** DatabaseTransactionTask ***
// Starts a transaction that will report its results via a callback.

DatabaseBackend::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend> transaction)
    : DatabaseTask(Database::from(transaction->database()), 0)
    , m_transaction(transaction)
{
}

DatabaseBackend::DatabaseTransactionTask::~DatabaseTransactionTask()
{
}

void DatabaseBackend::DatabaseTransactionTask::doPerformTask()
{
    m_transaction->performNextStep();
}

void DatabaseBackend::DatabaseTransactionTask::taskCancelled()
{
    // If the task is being destructed without the transaction ever being run,
    // then we must either have an error or an interruption. Give the
    // transaction a chance to clean up since it may not have been able to
    // run to its clean up state.

    // Transaction phase 2 cleanup. See comment on "What happens if a
    // transaction is interrupted?" at the top of SQLTransactionBackend.cpp.

    m_transaction->notifyDatabaseThreadIsShuttingDown();
}

#if !LOG_DISABLED
const char* DatabaseBackend::DatabaseTransactionTask::debugTaskName() const
{
    return "DatabaseTransactionTask";
}
#endif

// *** DatabaseTableNamesTask ***
// Retrieves a list of all tables in the database - for WebInspector support.

DatabaseBackend::DatabaseTableNamesTask::DatabaseTableNamesTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
    : DatabaseTask(database, synchronizer)
    , m_tableNames(names)
{
    ASSERT(synchronizer); // A task with output parameters is supposed to be synchronous.
}

void DatabaseBackend::DatabaseTableNamesTask::doPerformTask()
{
    m_tableNames = Database::from(database())->performGetTableNames();
}

#if !LOG_DISABLED
const char* DatabaseBackend::DatabaseTableNamesTask::debugTaskName() const
{
    return "DatabaseTableNamesTask";
}
#endif

} // namespace WebCore


text:
'use strict';

var expect = require('chai').expect;

var maleFirstNames = ['James', 'John', 'Robert', 'Michael', 'William', 'David',
  'Richard', 'Charles', 'Joseph', 'Thomas', 'Christopher', 'Daniel', 'Paul',
  'Mark', 'Donald', 'George', 'Kenneth', 'Steven', 'Edward', 'Brian', 'Ronald',
  'Anthony', 'Kevin', 'Jason', 'Matthew', 'Gary', 'Timothy', 'Jose', 'Larry',
  'Jeffrey', 'Frank', 'Scott', 'Eric'];

var femaleFirstNames = ['Mary', 'Patricia', 'Linda', 'Barbara', 'Elizabeth',
  'Jennifer', 'Maria', 'Susan', 'Margaret', 'Dorothy', 'Lisa', 'Nancy', 'Karen',
  'Betty', 'Helen', 'Sandra', 'Donna', 'Carol', 'Ruth', 'Sharon', 'Michelle',
  'Laura', 'Sarah', 'Kimberly', 'Deborah', 'Jessica', 'Shirley', 'Cynthia',
  'Angela', 'Melissa', 'Brenda', 'Amy', 'Anna'];

var lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Miller',
  'Davis', 'Garcia', 'Rodriguez', 'Wilson', 'Martinez', 'Anderson', 'Taylor',
  'Thomas', 'Hernandez', 'Moore', 'Martin', 'Jackson', 'Thompson', 'White',
  'Lopez', 'Lee', 'Gonzalez', 'Harris', 'Clark', 'Lewis', 'Robinson', 'Walker',
  'Perez', 'Hall', 'Young', 'Allen'];

describe('names: ', function () {

  var random = require('../../');

  it('common', function () {

    expect(random.maleFirstName()).to.be.a('string');
    expect(random.maleFirstName()).to.be.oneOf(maleFirstNames);

    expect(random.femaleFirstName()).to.be.a('string');
    expect(random.femaleFirstName()).to.be.oneOf(femaleFirstNames);

    expect(random.lastName()).to.be.a('string');
    expect(random.lastName()).to.be.oneOf(lastNames);

    expect(random.name()).to.be.a('string');
    expect(random.name('middle')).to.have.string('middle');
  });
});


text:
(function() {
  if (window.location.href.indexOf("file:") == 0) {
    // NO OP - possibly do something here to indicate remote doesn't work from local file?
  }
  else {
    //shortcuts for typing purposes
    var assert = TinyTest.assert;
    var done = TinyTest.done;
    var warn = TinyTest.warn;

    //register unit tests
    TinyTest.registerTests([
      {
        name: "Remote Messages - Test Hello World",
        suite: "remote",
        unit_test: function() {
          var receivedWithPayload = false;
          var scopeWorked = true;

          //Should receive response
          mq.sub("r:say.hello.response",function(msg) {
            if (msg.payload == "Hello World!") {
              receivedWithPayload = true;
            }
          });

          //Should NOT receive response due to scope
          mq.sub("r:say.hello.response",function(msg) {
            scopeWorked = false;
          },{
            scope:"myscope"
          });

          //Send remote message
          mq.pub("r:say.hello.request");

          //Test after we've had some time to get a response
          setTimeout(function() {
            assert(receivedWithPayload, "Remote response received with proper payload.");
            assert(scopeWorked, "Remote response has proper default scope assigned");
            done();
          },3000);
        }
      },
      {
        name: "Remote Messages - Test server side filters",
        suite: "remote",
        unit_test: function() {
          assert(true,"");
          done();
        }
      }
    ]);
  }
})();


text:
<?php
namespace ZfcDatagridTest;

use PHPUnit_Framework_TestCase;
use ZfcDatagrid\Column\Type\Number;
use ZfcDatagrid\Filter;

/**
 * @covers \ZfcDatagrid\Filter
 */
class FilterTest extends PHPUnit_Framework_TestCase
{
    /** @var \ZfcDatagrid\Column\AbstractColumn|\PHPUnit_Framework_MockObject_MockObject  */
    private $column;

    public function setUp()
    {
        $this->column = $this->getMockForAbstractClass(\ZfcDatagrid\Column\AbstractColumn::class);
    }

    public function tearDown()
    {
        $this->column = null;
    }

    public function testDefaultOperator()
    {
        $filter = new Filter();

        $this->assertFalse($filter->isColumnFilter());

        $filter->setFromColumn($this->column, 'test');
        $this->assertEquals($this->column, $filter->getColumn());
        $this->assertEquals(Filter::LIKE, $filter->getOperator());
//         $this->assertEquals('~ *test*', $filter->getDisplayColumnValue());
        $this->assertTrue(is_array($filter->getValues()));
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        $this->assertTrue($filter->isColumnFilter());
    }

    public function testEqualEmpty()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '=');
        $this->assertEquals($this->column, $filter->getColumn());
        $this->assertEquals(Filter::EQUAL, $filter->getOperator());
//         $this->assertEquals('= ', $filter->getDisplayColumnValue());
        $this->assertTrue(is_array($filter->getValues()));
        $this->assertEquals([
            '',
        ], $filter->getValues());

        $this->assertTrue($filter->isColumnFilter());
    }

    public function testLike()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '~test');
        $this->assertEquals(Filter::LIKE, $filter->getOperator());
//         $this->assertEquals('~ *test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 2
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '~*test*');
        $this->assertEquals(Filter::LIKE, $filter->getOperator());
//         $this->assertEquals('~ *test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 3
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '~%test%');
        $this->assertEquals(Filter::LIKE, $filter->getOperator());
//         $this->assertEquals('~ *test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testLikeLeft()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '~%test');
        $this->assertEquals(Filter::LIKE_LEFT, $filter->getOperator());
//         $this->assertEquals('~ *test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 2
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '~*test');
        $this->assertEquals(Filter::LIKE_LEFT, $filter->getOperator());
//         $this->assertEquals('~ *test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testLikeRight()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '~test%');
        $this->assertEquals(Filter::LIKE_RIGHT, $filter->getOperator());
//         $this->assertEquals('~ test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 2
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '~test*');
        $this->assertEquals(Filter::LIKE_RIGHT, $filter->getOperator());
//         $this->assertEquals('~ test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testNotLike()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!~test');
        $this->assertEquals(Filter::NOT_LIKE, $filter->getOperator());
//         $this->assertEquals('!~ *test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 2
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!~*test*');
        $this->assertEquals(Filter::NOT_LIKE, $filter->getOperator());
//         $this->assertEquals('!~ *test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 3
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!~%test%');
        $this->assertEquals(Filter::NOT_LIKE, $filter->getOperator());
//         $this->assertEquals('!~ *test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testNotLikeLeft()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!~%test');
        $this->assertEquals(Filter::NOT_LIKE_LEFT, $filter->getOperator());
//         $this->assertEquals('!~ *test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 2
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!~*test');
        $this->assertEquals(Filter::NOT_LIKE_LEFT, $filter->getOperator());
//         $this->assertEquals('!~ *test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testNotLikeRight()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!~test%');
        $this->assertEquals(Filter::NOT_LIKE_RIGHT, $filter->getOperator());
//         $this->assertEquals('!~ test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 2
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!~test*');
        $this->assertEquals(Filter::NOT_LIKE_RIGHT, $filter->getOperator());
//         $this->assertEquals('!~ test*', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testEqual()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '=test');
        $this->assertEquals(Filter::EQUAL, $filter->getOperator());
//         $this->assertEquals('= test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 2
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '==test');
        $this->assertEquals(Filter::EQUAL, $filter->getOperator());
//         $this->assertEquals('= test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Case 3
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '==test,value2');
        $this->assertEquals(Filter::EQUAL, $filter->getOperator());
//         $this->assertEquals('= test,value2', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
            'value2',
        ], $filter->getValues());
    }

    public function testNotEqual()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!test');
        $this->assertEquals(Filter::NOT_EQUAL, $filter->getOperator());
//         $this->assertEquals('!= test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());

        /*
         * Equal 2
         */
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!=test');
        $this->assertEquals(Filter::NOT_EQUAL, $filter->getOperator());
//         $this->assertEquals('!= test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testGreaterEqual()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '>=test');
        $this->assertEquals(Filter::GREATER_EQUAL, $filter->getOperator());
//         $this->assertEquals('>= test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testGreater()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '>test');
        $this->assertEquals(Filter::GREATER, $filter->getOperator());
//         $this->assertEquals('> test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testLessEqual()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '<=test');
        $this->assertEquals(Filter::LESS_EQUAL, $filter->getOperator());
//         $this->assertEquals('<= test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testLess()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '<test');
        $this->assertEquals(Filter::LESS, $filter->getOperator());
//         $this->assertEquals('< test', $filter->getDisplayColumnValue());
        $this->assertEquals([
            'test',
        ], $filter->getValues());
    }

    public function testIn()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '=(test,test2)');
        $this->assertEquals(Filter::IN, $filter->getOperator());
//         $this->assertEquals('=(test,test2)', $filter->getDisplayColumnValue());

        // @todo wrong?
        $this->assertEquals([
            'test',
            'test2',
        ], $filter->getValues());
    }

    public function testNotIn()
    {
        $filter = new Filter();

        $filter->setFromColumn($this->column, '!=(test,test2)');
        $this->assertEquals(Filter::NOT_IN, $filter->getOperator());
//         $this->assertEquals('!=(test,test2)', $filter->getDisplayColumnValue());

        // @todo wrong?
        $this->assertEquals([
            'test',
            'test2',
        ], $filter->getValues());
    }

    public function testBetween()
    {
        $filter = new Filter();
        $filter->setFromColumn($this->column, '2<>3');

        $this->assertEquals(Filter::BETWEEN, $filter->getOperator());
//         $this->assertEquals('2 <> 3', $filter->getDisplayColumnValue());
        $this->assertEquals([
            '2',
            '3',
        ], $filter->getValues());

        $filter = new Filter();
        $filter->setFromColumn($this->column, '2<>3 <>4');

        $this->assertEquals(Filter::BETWEEN, $filter->getOperator());
//         $this->assertEquals('2 <> 4', $filter->getDisplayColumnValue());
        $this->assertEquals([
            '2',
            '4',
        ], $filter->getValues());
    }

    public function testIsArrayComma()
    {
        $filter = new Filter();
        $filter->setFromColumn($this->column, '=2,5');

        $this->assertEquals(Filter::EQUAL, $filter->getOperator());
        $this->assertEquals([2, 5], $filter->getValues());
    }

    public function testIsArrayCommaWithNumber()
    {
        $number = new Number();
        $number->setLocale('en');

        $this->column->setType($number);

        $filter = new Filter();
        $filter->setFromColumn($this->column, '=2,5');

        $this->assertEquals(Filter::EQUAL, $filter->getOperator());
        $this->assertSame(['2,5'], $filter->getValues());
    }

    public function testIsApplyLike()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply('123', '123', Filter::LIKE));
        $this->assertTrue($filter->isApply('123asdf', '123', Filter::LIKE));
        $this->assertTrue($filter->isApply('text123text', '123', Filter::LIKE));
        $this->assertTrue($filter->isApply('asdf myString', 'myString', Filter::LIKE));
        $this->assertTrue($filter->isApply('smallWritten', 'SMALLWRITTEN', Filter::LIKE));

        $this->assertFalse($filter->isApply('smallWritten', 'somethingDifferent', Filter::LIKE));
    }

    public function testIsApplyLikeLeft()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply('123', '123', Filter::LIKE_LEFT));
        $this->assertTrue($filter->isApply('asdf123', '123', Filter::LIKE_LEFT));
        $this->assertTrue($filter->isApply('smallWritten', 'SMALLWRITTEN', Filter::LIKE_LEFT));

        $this->assertFalse($filter->isApply('text123text', '123', Filter::LIKE_LEFT), '123 %~ text123text');
        $this->assertFalse($filter->isApply('myString asdf', 'myString', Filter::LIKE_LEFT), 'myString %~ myString asdf');
        $this->assertFalse($filter->isApply('smallWritten', 'somethingDifferent', Filter::LIKE_LEFT), 'smallWritten %~ somethingDifferent');
    }

    public function testIsApplyLikeRight()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply('123', '123', Filter::LIKE_RIGHT));
        $this->assertTrue($filter->isApply('123asdf', 123, Filter::LIKE_RIGHT));
        $this->assertTrue($filter->isApply('smallWritten', 'SMALLWRITTEN', Filter::LIKE_RIGHT));

        $this->assertFalse($filter->isApply('text123text', '123', Filter::LIKE_RIGHT));
        $this->assertFalse($filter->isApply('asdf myString', 'myString', Filter::LIKE_RIGHT));
        $this->assertFalse($filter->isApply('smallWritten', 'somethingDifferent', Filter::LIKE_RIGHT));
    }

    public function testIsApplyNotLike()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply(123, 456, Filter::NOT_LIKE));

        $this->assertFalse($filter->isApply('test123', 123, Filter::NOT_LIKE));
        $this->assertFalse($filter->isApply('123test', 123, Filter::NOT_LIKE));
        $this->assertFalse($filter->isApply('test123test', 123, Filter::NOT_LIKE));
        $this->assertFalse($filter->isApply(123, '123', Filter::NOT_LIKE));
    }

    public function testIsApplyNotLikeLeft()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply(123, 456, Filter::NOT_LIKE_LEFT));
        $this->assertTrue($filter->isApply(1234, 123, Filter::NOT_LIKE_LEFT));

        $this->assertFalse($filter->isApply(123, '123', Filter::NOT_LIKE_LEFT));
        $this->assertFalse($filter->isApply('asdf123', 123, Filter::NOT_LIKE_LEFT));
    }

    public function testIsApplyNotLikeRight()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply(123, 456, Filter::NOT_LIKE_RIGHT));
        $this->assertTrue($filter->isApply(4123, 123, Filter::NOT_LIKE_RIGHT));

        $this->assertFalse($filter->isApply(123, '123', Filter::NOT_LIKE_RIGHT));
        $this->assertFalse($filter->isApply('123asdf', 123, Filter::NOT_LIKE_RIGHT));
    }

    public function testIsApplyEqual()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply('123', 123, Filter::EQUAL));
        $this->assertTrue($filter->isApply(123, '123', Filter::EQUAL));
        $this->assertTrue($filter->isApply('myString', 'myString', Filter::EQUAL));

        $this->assertFalse($filter->isApply('myString', 'MYSTRING', Filter::EQUAL));
        $this->assertFalse($filter->isApply('smallWritten', 'SMALLWRITTEN', Filter::EQUAL));
        $this->assertFalse($filter->isApply('smallWritten', 'somethingDifferent', Filter::EQUAL));
    }

    public function testIsApplyNotEqual()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply('smallWritten', 'somethingDifferent', Filter::NOT_EQUAL));
        $this->assertTrue($filter->isApply('myString', 'MYSTRING', Filter::NOT_EQUAL));
        $this->assertTrue($filter->isApply('smallWritten', 'SMALLWRITTEN', Filter::NOT_EQUAL));

        $this->assertFalse($filter->isApply('123', 123, Filter::NOT_EQUAL));
        $this->assertFalse($filter->isApply(123, '123', Filter::NOT_EQUAL));
        $this->assertFalse($filter->isApply('myString', 'myString', Filter::NOT_EQUAL));
    }

    public function testIsApplyGreaterEqual()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply('123', 123, Filter::GREATER_EQUAL));
        $this->assertTrue($filter->isApply(123, 100, Filter::GREATER_EQUAL));
        $this->assertTrue($filter->isApply('123.5', 100, Filter::GREATER_EQUAL));
        $this->assertTrue($filter->isApply('myString', 'myString', Filter::GREATER_EQUAL));

        $this->assertFalse($filter->isApply('123', 150, Filter::GREATER_EQUAL));
        $this->assertFalse($filter->isApply(149.99, 150, Filter::GREATER_EQUAL));
    }

    public function testIsApplyGreater()
    {
        $filter = new Filter();

        $this->assertTrue($filter->isApply(123, 100, Filter::GREATER));
        $this->assertTrue($filter->isApply('123.5', 100, Filter::GREATER));
        $this->assertTrue($filter->isApply('nyString', 'myString', Filter::GREATER));

        $this->assertFalse($filter->isApply('150', 150, Filter::GREATER));
        $this->assertFalse($filter->isApply(149, 150, Filter::GREATER));
    }

    public function testIsApplyLessEqual()
    {
        $filter = new Filter();

        $this->assertFalse($filter->isApply(123, 100, Filter::LESS_EQUAL));
        $this->assertFalse($filter->isApply('123.5', 100, Filter::LESS_EQUAL));

        $this->assertTrue($filter->isApply('myString', 'myString', Filter::LESS_EQUAL));
        $this->assertTrue($filter->isApply('123', 123, Filter::LESS_EQUAL));
        $this->assertTrue($filter->isApply('123', 150, Filter::LESS_EQUAL));
        $this->assertTrue($filter->isApply(149.99, 150, Filter::LESS_EQUAL));
    }

    public function testIsApplyLess()
    {
        $filter = new Filter();

        $this->assertFalse($filter->isApply(123, 100, Filter::LESS));
        $this->assertFalse($filter->isApply('123.5', 100, Filter::LESS));
        $this->assertFalse($filter->isApply('nyString', 'myString', Filter::LESS));
        $this->assertFalse($filter->isApply('150', 150, Filter::LESS));

        $this->assertTrue($filter->isApply(149, 150, Filter::LESS));
    }

    public function testIsApplyBetween()
    {
        $filter = new Filter();
        $this->assertTrue($filter->isApply(70, [
            50,
            100,
        ], Filter::BETWEEN));
        $this->assertTrue($filter->isApply(50, [
            50,
            100,
        ], Filter::BETWEEN));
        $this->assertTrue($filter->isApply(100, [
            50,
            100,
        ], Filter::BETWEEN));

        $this->assertFalse($filter->isApply(49, [
            50,
            100,
        ], Filter::BETWEEN));
        $this->assertFalse($filter->isApply(101, [
            50,
            100,
        ], Filter::BETWEEN));

        $this->assertFalse($filter->isApply(49.99, [
            50,
            100,
        ], Filter::BETWEEN));
    }

    /**
     * @expectedException \InvalidArgumentException
     */
    public function testIsApplyBetweenInvalidArgumentException()
    {
        $filter = new Filter();

        $filter->isApply(123, 100, Filter::BETWEEN);
    }

    /**
     * @expectedException \InvalidArgumentException
     */
    public function testIsApplyInvalidArgumentException()
    {
        $filter = new Filter();

        $filter->isApply(123, 100, 'UndefinedFilter');
    }
}


text:
<?xml version="1.0" ?>
<doc>
	<str name="Patent Number">
		US20120307425A1
	</str>
	<str name="Application Number">
		US13/227480
	</str>
	<str name="Kind Code">
		A1
	</str>
	<str name="Title">
		PORTABLE ELECTRONIC DEVICE AND BATTERY LOCKING MODULE
	</str>
	<str name="Abstract">
		A portable electronic device and a battery locking module capable to lock the battery and the battery slot cover in the housing of the portable electronic device through a locking element and an elastic element are provided. Especially, through the improvement design of the arrangement of the battery locking module in the housing, not only the inner space of the portable electronic device can be saved, a fool proof function is also provided since the battery slot cover is disabled to cover the opening of the battery slot if the battery is in a wrong position.
	</str>
	<str name="Document Types">
		US | USA
	</str>
	<str name="Application Date">
		2011-09-08
	</str>
	<str name="Application Year">
		2011
	</str>
	<str name="Application(Year/Month)">
		2011-09
	</str>
	<str name="Publication Date">
		2012-12-06
	</str>
	<str name="Publication Year">
		2012
	</str>
	<str name="Publication(Year/Month)">
		2012-12
	</str>
	<str name="All IPC">
		H05K7/00
	</str>
	<str name="IPC Primary">
		H05K7/00
	</str>
	<str name="IPC Section">
		H
	</str>
	<str name="IPC Class">
		H05
	</str>
	<str name="IPC Subclass">
		H05K
	</str>
	<str name="IPC Group">
		H05K7
	</str>
	<str name="All UPC">
		361/679.01
	</str>
	<str name="UPC Primary">
		361/679.01
	</str>
	<str name="UPC Class">
		361
	</str>
	<str name="Family Member Count">
		0
	</str>
	<str name="Family Members Cited By Count">
		0
	</str>
	<str name="Other References Count">
		0
	</str>
	<str name="Priority Country">
		TW
	</str>
	<str name="Priority Number">
		100119042
	</str>
	<str name="Priority Date">
		2011-05-31
	</str>
	<str name="Assignee(s)">
		ALTEK CORPORATION
	</str>
	<str name="1st Assignee">
		ALTEK CORPORATION
	</str>
	<str name="Number of Assignees">
		1
	</str>
	<str name="1st Assignee Address">
		Hsinchu City, TW
	</str>
	<str name="Assignee(s) Address">
		Hsinchu City, TW
	</str>
	<str name="Inventor(s)">
		LO, HUAN-CHUN
	</str>
	<str name="1st Inventor">
		LO, HUAN-CHUN
	</str>
	<str name="Number of Inventors">
		1
	</str>
	<str name="1st Inventor Address">
		Miaoli, County, TW
	</str>
	<str name="Inventor(s) Address">
		Miaoli, County, TW
	</str>
	<str name="cited by within 3 years">
		0
	</str>
	<str name="cited by within 5 years">
		0
	</str>
</doc>


text:
/**
 * Created by Mastermind on 19.5.2015 ã..
 */
function showResult() {
    var first = document.getElementById('tb-first').value;
    var result;

    switch (first) {
        case '0': result = 'zero';
            break;
        case '1': result = 'one';
            break;
        case '2': result = 'two';
            break;
        case '3': result = 'three';
            break;
        case '4': result = 'four';
            break;
        case '5': result = 'five';
            break;
        case '6': result = 'six';
            break;
        case '7': result = 'seven';
            break;
        case '8': result = 'eight';
            break;
        case '9': result = 'nine';
            break;
        default: result = 'not a digit'
            break;
    }

    document.getElementById('result').innerHTML = result;
}


text:
class Engine:

    def __init__(self,
                 response_pairs,
                 knowledge={}):
        self.response_pairs = response_pairs
        self.knowledge = knowledge

    def chat(self, user_utterance, context):
        best_score = 0
        best_response_pair = None
        best_captured = {}
        for response_pair in self.response_pairs:
            captured = response_pair.match(user_utterance, self.knowledge)

            if captured is None:
                continue

            score = response_pair.score(captured, context, self.knowledge)

            if best_score < score:
                best_score, best_response_pair, best_captured = score, response_pair, captured

        response, new_context = best_response_pair.generate(best_captured, context, self.knowledge)
        return response, new_context, best_score


text:
package org.jfrog.hudson.pipeline.common.types.deployers;

import com.fasterxml.jackson.annotation.JsonIgnore;
import org.apache.commons.lang.StringUtils;
import org.jenkinsci.plugins.scriptsecurity.sandbox.whitelists.Whitelisted;
import org.jfrog.hudson.RepositoryConf;
import org.jfrog.hudson.ServerDetails;
import org.jfrog.hudson.action.ActionableHelper;
import org.jfrog.hudson.pipeline.common.types.ArtifactoryServer;
import org.jfrog.hudson.util.ExtractorUtils;
import org.jfrog.hudson.util.publisher.PublisherContext;

/**
 * Created by Tamirh on 16/08/2016.
 */
public class MavenDeployer extends Deployer {
    private String snapshotRepo;
    private String releaseRepo;
    private boolean deployEvenIfUnstable = false;
    public final static MavenDeployer EMPTY_DEPLOYER;

    static {
        EMPTY_DEPLOYER = createEmptyDeployer();
    }

    @Whitelisted
    public String getReleaseRepo() {
        return releaseRepo;
    }

    @Whitelisted
    public MavenDeployer setReleaseRepo(String releaseRepo) {
        this.releaseRepo = releaseRepo;
        return this;
    }

    @Whitelisted
    public MavenDeployer setSnapshotRepo(String snapshotRepo) {
        this.snapshotRepo = snapshotRepo;
        return this;
    }

    @Whitelisted
    public String getSnapshotRepo() {
        return snapshotRepo;
    }

    @Whitelisted
    public Deployer setDeployEvenIfUnstable(boolean deployEvenIfUnstable) {
        this.deployEvenIfUnstable = deployEvenIfUnstable;
        return this;
    }

    /**
     * @return True if should deploy artifacts even when the build is unstable (test failures).
     */
    @Whitelisted
    public boolean isDeployEvenIfUnstable() {
        return deployEvenIfUnstable;
    }

    @Override
    @JsonIgnore
    public ServerDetails getDetails() {
        RepositoryConf snapshotRepositoryConf = new RepositoryConf(snapshotRepo, snapshotRepo, false);
        RepositoryConf releaesRepositoryConf = new RepositoryConf(releaseRepo, releaseRepo, false);
        return new ServerDetails(this.server.getServerName(), this.server.getUrl(), releaesRepositoryConf, snapshotRepositoryConf, releaesRepositoryConf, snapshotRepositoryConf, "", "");
    }

    @Override
    @JsonIgnore
    public PublisherContext.Builder getContextBuilder() {
        return new PublisherContext.Builder().artifactoryServer(getArtifactoryServer())
                .deployerOverrider(this)
                .serverDetails(getDetails())
                .deployArtifacts(isDeployArtifacts())
                .evenIfUnstable(isDeployEvenIfUnstable())
                .artifactoryPluginVersion(ActionableHelper.getArtifactoryPluginVersion())
                .includeEnvVars(isIncludeEnvVars())
                .skipBuildInfoDeploy(!isDeployBuildInfo())
                .deploymentProperties(ExtractorUtils.buildPropertiesString(getProperties()))
                .includesExcludes(getArtifactsIncludeExcludeForDeyployment());
    }

    public boolean isEmpty() {
        return server == null || (StringUtils.isEmpty(releaseRepo) && StringUtils.isEmpty(snapshotRepo));
    }

    public String getTargetRepository(String deployPath) {
        return StringUtils.isNotBlank(snapshotRepo) && deployPath.contains("-SNAPSHOT") ? snapshotRepo : releaseRepo;
    }

    private static MavenDeployer createEmptyDeployer() {
        MavenDeployer dummy = new MavenDeployer();
        ArtifactoryServer server = new ArtifactoryServer("http://empty_url", "user", "password");
        dummy.setServer(server);
        dummy.setReleaseRepo("empty_repo");
        dummy.setSnapshotRepo("empty_repo");
        dummy.setDeployArtifacts(false);
        dummy.setDeployEvenIfUnstable(false);
        return dummy;
    }
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>Lucid Dreaming</title>

    <link href="css/bootstrap.min.css" rel="stylesheet">

    <link href="css/clean-blog.min.css" rel="stylesheet">

    <link href="http://maxcdn.bootstrapcdn.com/font-awesome/4.1.0/css/font-awesome.min.css" rel="stylesheet" type="text/css">
    <link href='http://fonts.googleapis.com/css?family=Lora:400,700,400italic,700italic' rel='stylesheet' type='text/css'>
    <link href='http://fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel='stylesheet' type='text/css'>

Lucid Dreaming

                        Created by Victoria Brown and Lucas Miller

                            What is dreaming?

                            Mental activity, who does it, interpretations

                            Lucid Dreaming

                            Origins, dream control, proof, benefits

                            How to Learn

                            Techniques, routines, speed

                            Additional Resources

                            Websites, research papers, books


text:
<?xml version="1.0" encoding="utf-8"?>

<!--
    Linux on Hyper-V and Azure Test Code, ver. 1.0.0
    Copyright (c) Microsoft Corporation

    All rights reserved.
    Licensed under the Apache License, Version 2.0 (the ""License"");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
    OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
    ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR
    PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing
    permissions and limitations under the License.
-->

<config>
    <global>
        <logfileRootDir>TestResults</logfileRootDir>
        <defaultSnapshot>ICABase</defaultSnapshot>
        <dependency>
            <!-- Only Windows Server 2012 R2 and newer supports this feature -->
            <hostVersion>6.3.9600</hostVersion>
        </dependency>
        <email>
            <recipients>
                <to>myself@mail.com</to>
                <to>myboss@mail.com</to>
            </recipients>
            <sender>myself@mail.com</sender>
            <subject>LISA VHDx Resize Tests Run</subject>
            <smtpServer>smtp.your.company.com</smtpServer>
        </email>
    </global>

    <testSuites>
        <suite>
            <suiteName>VHDxResize</suiteName>
            <suiteTests>
                <suiteTest>VHDxResizeToBigger512</suiteTest>
                <suiteTest>VHDxResizeToBigger4096</suiteTest>
                <suiteTest>VHDxResizeToBigger512_Dynamic_IDE</suiteTest>
                <suiteTest>VHDxResizeToBigger512_Fixed_IDE</suiteTest>
                <suiteTest>VHDxResizeToSmaller512</suiteTest>
                <suiteTest>VHDxResizeToSmaller4096</suiteTest>
                <suiteTest>VHDxResizeGrowShrink_SCSI</suiteTest>
                <suiteTest>VHDxResizeGrowShrink_IDE</suiteTest>
                <suiteTest>VHDxResizeGrowShrink_SCSI_Offline</suiteTest>
                <suiteTest>VHDxResizeGrowFilesystem512</suiteTest>
                <suiteTest>VHDxResizeGrowFilesystem4096</suiteTest>
                <suiteTest>VHDxResizeOver2TB_SCSI</suiteTest>
                <suiteTest>VHDxResizeOver2TB_IDE</suiteTest>
                <suiteTest>VHDxResizeGrowOver2TB_Shrink_SCSI_Online</suiteTest>
                <suiteTest>VHDxResizeGrowOver2TB_Shrink_SCSI_Offline</suiteTest>
                <suiteTest>VHDxResizeGrowOver2TB_Shrink_IDE</suiteTest>
                <!-- The below test case requires the VM to run on a cluster setup -->
                <suiteTest>VHDxResize_Live_Migration</suiteTest>
            </suiteTests>
        </suite>
    </testSuites>

    <testCases>
        <test>
            <testName>VHDxResizeToBigger512</testName>
            <testScript>SetupScripts\STOR_VHDXResize_Basic.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=3GB</param>
                <param>NewSize=4GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-01a</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResizeToBigger4096</testName>
            <testScript>SetupScripts\STOR_VHDXResize_Basic.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=4096</param>
                <param>DefaultSize=3GB</param>
                <param>NewSize=4GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-01b</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResizeToBigger512_Fixed_IDE</testName>
            <testScript>SetupScripts\STOR_VHDXResize_Basic.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Fixed</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=1GB</param>
                <param>NewSize=2GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=IDE</param>
                <param>TC_COVERED=STOR-VHDx-105</param>
             </testparams>
       </test>

       <test>
            <testName>VHDxResizeToBigger512_Dynamic_IDE</testName>
            <testScript>SetupScripts\STOR_VHDXResize_Basic.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=1GB</param>
                <param>NewSize=4GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=IDE</param>
                <param>TC_COVERED=STOR-VHDx-106</param>
            </testparams>
       </test>

        <test>
            <testName>VHDxResizeToSmaller512</testName>
            <testScript>SetupScripts\STOR_VHDXResize_Basic.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=3GB</param>
                <param>NewSize=2GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-02a</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResizeToSmaller4096</testName>
            <testScript>SetupScripts\STOR_VHDXResize_Basic.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=4096</param>
                <param>DefaultSize=3GB</param>
                <param>NewSize=2GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-02b</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResizeGrowShrink_SCSI</testName>
            <testScript>SetupScripts\STOR_VHDXResize_GrowShrink.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=3GB</param>
                <param>growSize=4GB</param>
                <param>shrinkSize=3GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-03a</param>
            </testparams>
        </test>

      <test>
          <testName>VHDxResizeGrowShrink_IDE</testName>
          <testScript>SetupScripts\STOR_VHDXResize_GrowShrink.ps1</testScript>
          <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
          <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
          <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
          <timeout>600</timeout>
          <onError>Continue</onError>
          <testparams>
              <param>Type=Dynamic</param>
              <param>SectorSize=512</param>
              <param>DefaultSize=3GB</param>
              <param>growSize=4GB</param>
              <param>shrinkSize=3GB</param>
              <param>fileSystems=(ext4 ext3 xfs)</param>
              <param>ControllerType=IDE</param>
              <param>TC_COVERED=STOR-VHDx-03b</param>
          </testparams>
        </test>

        <test>
           <testName>VHDxResizeGrowShrink_SCSI_Offline</testName>
           <testScript>SetupScripts\STOR_VHDXResize_GrowShrink.ps1</testScript>
           <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
           <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
           <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
           <timeout>600</timeout>
           <onError>Continue</onError>
           <testparams>
               <param>Type=Dynamic</param>
               <param>SectorSize=512</param>
               <param>DefaultSize=3GB</param>
               <param>growSize=4GB</param>
               <param>shrinkSize=3GB</param>
               <param>fileSystems=(ext4 ext3 xfs)</param>
               <param>ControllerType=SCSI</param>
               <param>Offline=True</param>
               <param>TC_COVERED=STOR-VHDx-03c</param>
           </testparams>
        </test>

        <test>
            <testName>VHDxResizeGrowFilesystem512</testName>
            <testScript>SetupScripts\STOR_VHDXResize_GrowFS.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=3GB</param>
                <param>NewSize=4GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-04a</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResizeGrowFilesystem4096</testName>
            <testScript>SetupScripts\STOR_VHDXResize_GrowFS.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=4096</param>
                <param>DefaultSize=3GB</param>
                <param>NewSize=4GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-04b</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResizeOver2TB_SCSI</testName>
            <testScript>SetupScripts\STOR_VHDXResize_DiskOver2TB.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>3000</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=127GB</param>
                <param>NewSize=2304GB</param>
                <param>fileSystems=(ext4 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-05a</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResizeOver2TB_IDE</testName>
            <testScript>SetupScripts\STOR_VHDXResize_Basic.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>3000</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=127GB</param>
                <param>NewSize=2304GB</param>
                <param>fileSystems=(ext4 xfs)</param>
                <param>ControllerType=IDE</param>
                <param>TC_COVERED=STOR-VHDx-05b</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResizeGrowOver2TB_Shrink_SCSI_Online</testName>
            <testScript>SetupScripts\STOR_VHDXResize_GrowShrink.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=3GB</param>
                <param>growSize=2304GB</param>
                <param>shrinkSize=3GB</param>
                <param>fileSystems=(ext4 xfs)</param>
                <param>ControllerType=SCSI</param>
               <param>TC_COVERED=STOR-VHDx-06a</param>
            </testparams>
       </test>

       <test>
           <testName>VHDxResizeGrowOver2TB_Shrink_SCSI_Offline</testName>
           <testScript>SetupScripts\STOR_VHDXResize_GrowShrink.ps1</testScript>
           <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
           <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
           <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
           <timeout>600</timeout>
           <onError>Continue</onError>
           <testparams>
               <param>Type=Dynamic</param>
               <param>SectorSize=512</param>
               <param>DefaultSize=3GB</param>
               <param>growSize=2304GB</param>
               <param>shrinkSize=3GB</param>
               <param>fileSystems=(ext4 xfs)</param>
               <param>ControllerType=SCSI</param>
               <param>Offline=True</param>
               <param>TC_COVERED=STOR-VHDx-06b</param>
           </testparams>
        </test>

        <test>
            <testName>VHDxResizeGrowOver2TB_Shrink_IDE</testName>
            <testScript>SetupScripts\STOR_VHDXResize_GrowShrink.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=3GB</param>
                <param>growSize=2304GB</param>
                <param>shrinkSize=3GB</param>
                <param>fileSystems=(ext4 xfs)</param>
                <param>ControllerType=IDE</param>
                <param>TC_COVERED=STOR-VHDx-06c</param>
            </testparams>
        </test>

        <test>
            <testName>VHDxResize_Live_Migration</testName>
            <testScript>SetupScripts\STOR_VHDXResize_BasicLM.ps1</testScript>
            <setupScript>SetupScripts\Add-VHDXForResize.ps1</setupScript>
            <cleanupScript>SetupScripts\Remove-VHDXHardDisk.ps1</cleanupScript>
            <files>remote-scripts/ica/STOR_VHDXResize_ReadWrite.sh</files>
            <files>remote-scripts/ica/check_traces.sh</files>
            <timeout>600</timeout>
            <onError>Continue</onError>
            <testparams>
                <param>Type=Dynamic</param>
                <param>SectorSize=512</param>
                <param>DefaultSize=3GB</param>
                <param>NewSize=4GB</param>
                <param>fileSystems=(ext4 ext3 xfs)</param>
                <param>ControllerType=SCSI</param>
                <param>TC_COVERED=STOR-VHDx-07</param>
            </testparams>
        </test>
    </testCases>

    <VMs>
        <vm>
            <hvServer>localhost</hvServer>
            <vmName>VM</vmName>
            <os>Linux</os>
            <ipv4></ipv4>
            <sshKey>linux_id_rsa.ppk</sshKey>
            <suite>VHDxResize</suite>
        </vm>
    </VMs>
</config>


text:
<?php
/**
 * Created by PhpStorm.
 * User: Lounge
 * Date: 5/6/2017
 * Time: 7:42 AM
 */

namespace Tusbol\CarsModule\Http\Controller;

use Anomaly\Streams\Platform\Http\Controller\PublicController;
use Tusbol\CarsModule\Model\Contract\ModelRepositoryInterface;

class ModelsController extends PublicController
{
    public function view(ModelRepositoryInterface $models,$slug) {
        if(!$models = $models->findBySlug($slug)) {
            abort(404);
        }
        $this->breadcrumbs->add('Home','/');
        $this->breadcrumbs->add('Product','/cars');
        $this->breadcrumbs->add($models->name,$models->route('view'));
        $this->template->set('meta_title',$models->name);
        $this->template->set('meta_description',$models->description);
        return $this->view->make('tusbol.module.cars::models.view',compact('models'));
    }
}


text:
set(CMAKE_DEPENDS_LANGUAGES
  "CXX"
  )
# The set of files for implicit dependencies of each language:
set(CMAKE_DEPENDS_CHECK_CXX
  "/Users/JorgeAlfredo/argos3-markov/controllers/footbot_gripping/footbot_gripping.cpp" "/Users/JorgeAlfredo/argos3-markov/build/controllers/footbot_gripping/CMakeFiles/footbot_gripping.dir/footbot_gripping.cpp.o"
  "/Users/JorgeAlfredo/argos3-markov/build/controllers/footbot_gripping/footbot_gripping_automoc.cpp" "/Users/JorgeAlfredo/argos3-markov/build/controllers/footbot_gripping/CMakeFiles/footbot_gripping.dir/footbot_gripping_automoc.cpp.o"
  )
set(CMAKE_CXX_COMPILER_ID "Clang")

# Preprocessor definitions for this target.
set(CMAKE_TARGET_DEFINITIONS_CXX
  "QT_CORE_LIB"
  "QT_GUI_LIB"
  "QT_WIDGETS_LIB"
  )

# The include file search paths:
set(CMAKE_CXX_TARGET_INCLUDE_PATH
  "controllers/footbot_gripping"
  "../controllers/footbot_gripping"
  "/System/Library/Frameworks/OpenGL.framework/Headers"
  "/usr/local/opt/qt5/lib/QtWidgets.framework"
  "/usr/local/opt/qt5/lib/QtWidgets.framework/Headers"
  "/usr/local/opt/qt5/lib/QtGui.framework"
  "/usr/local/opt/qt5/lib/QtGui.framework/Headers"
  "/usr/local/opt/qt5/lib/QtCore.framework"
  "/usr/local/opt/qt5/lib/QtCore.framework/Headers"
  "/usr/local/opt/qt5/./mkspecs/macx-clang"
  "/usr/local/include"
  "../"
  "/usr/local/Cellar/argos3/3.0.0-beta45/include"
  "../controllers"
  )

# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
  )

# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")


text:
layout: page
title: Jacob Ray's 57th Birthday
date: 2016-05-24
author: Jack Kerr
tags: weekly links, java
status: published
summary: In eu fermentum tellus. Donec id massa erat. Morbi.
banner: images/banner/meeting-01.jpg
booking:
  startDate: 12/07/2019
  endDate: 12/10/2019
  ctyhocn: HNVHHHX
  groupCode: JR5B
published: true
---
Nam non mauris ac tortor ultricies sollicitudin. Fusce placerat vestibulum molestie. Nam hendrerit mauris justo, sit amet dictum nunc sollicitudin sit amet. Donec bibendum turpis vel mauris consequat, sed iaculis libero molestie. Nam eu libero odio. Aenean sagittis metus vel enim euismod vestibulum. Donec porta dapibus neque, eleifend maximus nisi ultricies eu. Nullam sit amet feugiat neque, sed placerat lorem. Vivamus bibendum blandit nunc, at volutpat leo venenatis et.

1 Maecenas vel magna in mauris vulputate eleifend.

Nulla vehicula finibus arcu et imperdiet. Curabitur a ultricies lorem. Pellentesque luctus id arcu aliquam laoreet. Proin dignissim augue ac ex pulvinar facilisis et ac velit. Vivamus at rutrum dolor. In in ligula vitae nisi semper vulputate ac non enim. Vestibulum et volutpat nibh.
Aenean imperdiet commodo luctus. Sed ut nisi eget enim auctor varius ac eget nibh. In porta enim sed placerat placerat. Integer egestas sagittis laoreet. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Phasellus eget urna in eros varius bibendum. Pellentesque mattis tristique dictum. Etiam tellus dui, varius quis tincidunt ac, feugiat eget ante. Aenean imperdiet mauris et libero ornare, sit amet sagittis turpis dictum. Morbi turpis leo, facilisis ut mauris at, tincidunt gravida dolor.


text:
Android RuntimePermissionsBasic Sample
======================================

This repo has been migrated to [github.com/android/permissions-samples][1]. Please check that repo for future updates. Thank you!

[1]: https://github.com/android/permissions-samples
 OR CONDITIONS OF ANY KIND, either express or implied.  See the
License for the specific language governing permissions and limitations under
the License.


text:
> AWS Lambda function that will stop servers that have a tag with the key `StopGroup` and the value the name of the lambda function.

## Usage

Download the [zip](https://github.com/SamVerschueren/aws-lambda-stop-server/releases) file and deploy it as a lambda function.

After you deployed the lambda function, you navigate to `Event sources` and choose for the `Scheduled Event`. After naming your event, you can provide
the following schedule expression.

```
cron(15 17 ? * MON-FRI *)
```

This expression wil stop the servers every weekday, from monday to friday, at 17:15 PM.

### Tags

Tagging your instance is very important in order for the lambda function to work properly. The lambda function will retrieve all the instances that have a tag with a key `StopGroup`,
and a value being the name of the lambda function you provided.

For instance, if you named your lambda function `OfficeHoursTerminator`, make sure you add a tag with key-value `StopGroup=OfficeHoursTerminator` to all the instances you want to stop
at the provided schedule.

### IAM Role

Make sure your lambda function is able to describe and stop instances.

```json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "MyStatementId",
            "Effect": "Allow",
            "Action": [
                "ec2:DescribeInstances",
                "ec2:StopInstances"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}
```

## Related

- [aws-lambda-start-server](https://github.com/SamVerschueren/aws-lambda-start-server) - The same function but for starting the server.

## License

MIT © Sam Verschueren


text:
package wox.serial;

import java.util.HashMap;

/**
 * The TypeMapping class provides the type mappings
 * from Java to WOX and viceversa. This class has an important role
 * in the standard XML representation of WOX. For more information about
 * the XML representation please visit: http://woxserializer.sourceforge.net/
 *
 * @author Carlos R. Jaimez Gonzalez

 *         Simon M. Lucas
 * @version TypeMapping.java - 1.0
 */
public class TypeMapping {

    //**********************************************************
    //09 October 2007
    /**Map from Java types to WOX types*/
    public static final HashMap mapJavaToWOX = new HashMap();
    /**Map from WOX types to Java types*/
    public static final HashMap mapWOXToJava = new HashMap();

    /**Map from Java array types to WOX array types*/
    public static final HashMap mapArrayJavaToWOX = new HashMap();
    /**Map from WOX array types to Java array types*/
    public static final HashMap mapArrayWOXToJava = new HashMap();

    static{
        //initialise map of Java data types (primitive and Wrapper) to WOX data types
        mapJavaToWOX.put(byte.class, "byte");
        mapJavaToWOX.put(short.class, "short");
        mapJavaToWOX.put(int.class, "int");
        mapJavaToWOX.put(long.class, "long");
        mapJavaToWOX.put(float.class, "float");
        mapJavaToWOX.put(double.class, "double");
        mapJavaToWOX.put(char.class, "char");
        mapJavaToWOX.put(boolean.class, "boolean");
        mapJavaToWOX.put(Byte.class, "byte");
        mapJavaToWOX.put(Short.class, "short");
        mapJavaToWOX.put(Integer.class, "int");
        mapJavaToWOX.put(Long.class, "long");
        mapJavaToWOX.put(Float.class, "float");
        mapJavaToWOX.put(Double.class, "double");
        mapJavaToWOX.put(Character.class, "char");
        mapJavaToWOX.put(Boolean.class, "boolean");
        //initialise map of Java data types (String, Class and Array) to WOX data types
        mapJavaToWOX.put(String.class, "string");
        mapJavaToWOX.put(Class.class, "class");
        //mapJavaToWOX.put(Array.class, "array");
        //initialise map of Java primitive arrays to WOX arrays
        mapArrayJavaToWOX.put(byte[].class, "byte[]");
        mapArrayJavaToWOX.put(byte[][].class, "byte[][]");
        mapArrayJavaToWOX.put(byte[][][].class, "byte[][][]");
        mapArrayJavaToWOX.put(short[].class, "short[]");
        mapArrayJavaToWOX.put(short[][].class, "short[][]");
        mapArrayJavaToWOX.put(short[][][].class, "short[][][]");
        mapArrayJavaToWOX.put(int[].class, "int[]");
        mapArrayJavaToWOX.put(int[][].class, "int[][]");
        mapArrayJavaToWOX.put(int[][][].class, "int[][][]");
        mapArrayJavaToWOX.put(long[].class, "long[]");
        mapArrayJavaToWOX.put(long[][].class, "long[][]");
        mapArrayJavaToWOX.put(long[][][].class, "long[][][]");
        mapArrayJavaToWOX.put(float[].class, "float[]");
        mapArrayJavaToWOX.put(float[][].class, "float[][]");
        mapArrayJavaToWOX.put(float[][][].class, "float[][][]");
        mapArrayJavaToWOX.put(double[].class, "double[]");
        mapArrayJavaToWOX.put(double[][].class, "double[][]");
        mapArrayJavaToWOX.put(double[][][].class, "double[][][]");
        mapArrayJavaToWOX.put(char[].class, "char[]");
        mapArrayJavaToWOX.put(char[][].class, "char[][]");
        mapArrayJavaToWOX.put(char[][][].class, "char[][][]");
        mapArrayJavaToWOX.put(boolean[].class, "boolean[]");
        mapArrayJavaToWOX.put(boolean[][][].class, "boolean[][]");
        mapArrayJavaToWOX.put(boolean[][][].class, "boolean[][][]");
        //initialise map of Java wrapper arrays to WOX arrays
        mapArrayJavaToWOX.put(Byte[].class, "byteWrapper[]");
        mapArrayJavaToWOX.put(Byte[][].class, "byteWrapper[][]");
        mapArrayJavaToWOX.put(Byte[][][].class, "byteWrapper[][][]");
        mapArrayJavaToWOX.put(Short[].class, "shortWrapper[]");
        mapArrayJavaToWOX.put(Short[][].class, "shortWrapper[][]");
        mapArrayJavaToWOX.put(Short[][][].class, "shortWrapper[][][]");
        mapArrayJavaToWOX.put(Integer[].class, "intWrapper[]");
        mapArrayJavaToWOX.put(Integer[][].class, "intWrapper[][]");
        mapArrayJavaToWOX.put(Integer[][][].class, "intWrapper[][][]");
        mapArrayJavaToWOX.put(Long[].class, "longWrapper[]");
        mapArrayJavaToWOX.put(Long[][].class, "longWrapper[][]");
        mapArrayJavaToWOX.put(Long[][][].class, "longWrapper[][][]");
        mapArrayJavaToWOX.put(Float[].class, "floatWrapper[]");
        mapArrayJavaToWOX.put(Float[][].class, "floatWrapper[][]");
        mapArrayJavaToWOX.put(Float[][][].class, "floatWrapper[][][]");
        mapArrayJavaToWOX.put(Double[].class, "doubleWrapper[]");
        mapArrayJavaToWOX.put(Double[][].class, "doubleWrapper[][]");
        mapArrayJavaToWOX.put(Double[][][].class, "doubleWrapper[][][]");
        mapArrayJavaToWOX.put(Character[].class, "charWrapper[]");
        mapArrayJavaToWOX.put(Character[][].class, "charWrapper[][]");
        mapArrayJavaToWOX.put(Character[][][].class, "charWrapper[][][]");
        mapArrayJavaToWOX.put(Boolean[].class, "booleanWrapper[]");
        mapArrayJavaToWOX.put(Boolean[][].class, "booleanWrapper[][]");
        mapArrayJavaToWOX.put(Boolean[][][].class, "booleanWrapper[][][]");
        //initialise map of Java arrays of Class and String to WOX arrays
        mapArrayJavaToWOX.put(Class[].class, "class[]");
        mapArrayJavaToWOX.put(Class[][].class, "class[][]");
        mapArrayJavaToWOX.put(Class[][][].class, "class[][][]");
        mapArrayJavaToWOX.put(String[].class, "string[]");
        mapArrayJavaToWOX.put(String[][].class, "string[][]");
        mapArrayJavaToWOX.put(String[][][].class, "string[][][]");

        //************************************************************************************
        //initialise map of WOX data types to Java data types
        mapWOXToJava.put("byte", byte.class);
        mapWOXToJava.put("short", short.class);
        mapWOXToJava.put("int", int.class);
        mapWOXToJava.put("long", long.class);
        mapWOXToJava.put("float", float.class);
        mapWOXToJava.put("double", double.class);
        mapWOXToJava.put("char", char.class);
        mapWOXToJava.put("boolean", boolean.class);
        mapWOXToJava.put("byteWrapper", Byte.class);
        mapWOXToJava.put("shortWrapper", Short.class);
        mapWOXToJava.put("intWrapper", Integer.class);
        mapWOXToJava.put("longWrapper", Long.class);
        mapWOXToJava.put("floatWrapper", Float.class);
        mapWOXToJava.put("doubleWrapper", Double.class);
        mapWOXToJava.put("charWrapper", Character.class);
        mapWOXToJava.put("booleanWrapper", Boolean.class);
        //initialise map of WOX data types (String, Class and Array) to Java data types
        mapWOXToJava.put("string", String.class);
        mapWOXToJava.put("class", Class.class);
        //mapWOXToJava.put("array", Array.class);
        //initialise map of WOX primitive arrays to Java arrays
        mapArrayWOXToJava.put("byte[]", byte[].class);
        mapArrayWOXToJava.put("byte[][]", byte[][].class);
        mapArrayWOXToJava.put("byte[][][]", byte[][][].class);
        mapArrayWOXToJava.put("short[]", short[].class);
        mapArrayWOXToJava.put("short[][]", short[][].class);
        mapArrayWOXToJava.put("short[][][]", short[][][].class);
        mapArrayWOXToJava.put("int[]", int[].class);
        mapArrayWOXToJava.put("int[][]", int[][].class);
        mapArrayWOXToJava.put("int[][][]", int[][][].class);
        mapArrayWOXToJava.put("long[]", long[].class);
        mapArrayWOXToJava.put("long[][]", long[][].class);
        mapArrayWOXToJava.put("long[][][]", long[][][].class);
        mapArrayWOXToJava.put("float[]", float[].class);
        mapArrayWOXToJava.put("float[][]", float[][].class);
        mapArrayWOXToJava.put("float[][][]", float[][][].class);
        mapArrayWOXToJava.put("double[]", double[].class);
        mapArrayWOXToJava.put("double[][]", double[][].class);
        mapArrayWOXToJava.put("double[][][]", double[][][].class);
        mapArrayWOXToJava.put("char[]", char[].class);
        mapArrayWOXToJava.put("char[][]", char[][].class);
        mapArrayWOXToJava.put("char[][][]", char[][][].class);
        mapArrayWOXToJava.put("boolean[]", boolean[].class);
        mapArrayWOXToJava.put("boolean[][]", boolean[][].class);
        mapArrayWOXToJava.put("boolean[][][]", boolean[][][].class);
        //initialise map of WOX wrapper arrays to Java wrapper arrays
        mapArrayWOXToJava.put("byteWrapper[]", Byte[].class);
        mapArrayWOXToJava.put("byteWrapper[][]", Byte[][].class);
        mapArrayWOXToJava.put("byteWrapper[][][]", Byte[][][].class);
        mapArrayWOXToJava.put("shortWrapper[]", Short[].class);
        mapArrayWOXToJava.put("shortWrapper[][]", Short[][].class);
        mapArrayWOXToJava.put("shortWrapper[][][]", Short[][][].class);
        mapArrayWOXToJava.put("intWrapper[]", Integer[].class);
        mapArrayWOXToJava.put("intWrapper[][]", Integer[][].class);
        mapArrayWOXToJava.put("intWrapper[][][]", Integer[][][].class);
        mapArrayWOXToJava.put("longWrapper[]", Long[].class);
        mapArrayWOXToJava.put("longWrapper[][]", Long[][].class);
        mapArrayWOXToJava.put("longWrapper[][][]", Long[][][].class);
        mapArrayWOXToJava.put("floatWrapper[]", Float[].class);
        mapArrayWOXToJava.put("floatWrapper[][]", Float[][].class);
        mapArrayWOXToJava.put("floatWrapper[][][]", Float[][][].class);
        mapArrayWOXToJava.put("doubleWrapper[]", Double[].class);
        mapArrayWOXToJava.put("doubleWrapper[][]", Double[][].class);
        mapArrayWOXToJava.put("doubleWrapper[][][]", Double[][][].class);
        mapArrayWOXToJava.put("charWrapper[]", Character[].class);
        mapArrayWOXToJava.put("charWrapper[][]", Character[][].class);
        mapArrayWOXToJava.put("charWrapper[][][]", Character[][][].class);
        mapArrayWOXToJava.put("booleanWrapper[]", Boolean[].class);
        mapArrayWOXToJava.put("booleanWrapper[][]", Boolean[][].class);
        mapArrayWOXToJava.put("booleanWrapper[][][]", Boolean[][][].class);
        //initialise map of WOX arrays of Class and String to Java arrays
        mapArrayWOXToJava.put("class[]", Class[].class);
        mapArrayWOXToJava.put("class[][]", Class[][].class);
        mapArrayWOXToJava.put("class[][][]", Class[][][].class);
        mapArrayWOXToJava.put("string[]", String[].class);
        mapArrayWOXToJava.put("string[][]", String[][].class);
        mapArrayWOXToJava.put("string[][][]", String[][][].class);

    }

}


text:
namespace chrome {
namespace android {

void InitJavaExceptionReporter() {
  JNIEnv* env = base::android::AttachCurrentThread();
  Java_JavaExceptionReporter_installHandler(env);
}

void ReportJavaException(JNIEnv* env,
                         const JavaParamRef<jclass>& jcaller,
                         const JavaParamRef<jthrowable>& e) {
  // Set the exception_string in BuildInfo so that breakpad can read it.
  base::android::BuildInfo::GetInstance()->SetJavaExceptionInfo(
      base::android::GetJavaExceptionInfo(env, e));
  base::debug::DumpWithoutCrashing();
  base::android::BuildInfo::GetInstance()->ClearJavaExceptionInfo();
}

void ReportJavaStackTrace(JNIEnv* env,
                          const JavaParamRef<jclass>& jcaller,
                          const JavaParamRef<jstring>& stackTrace) {
  base::android::BuildInfo::GetInstance()->SetJavaExceptionInfo(
      ConvertJavaStringToUTF8(stackTrace));
  base::debug::DumpWithoutCrashing();
  base::android::BuildInfo::GetInstance()->ClearJavaExceptionInfo();
}

bool RegisterJavaExceptionReporterJni(JNIEnv* env) {
  return RegisterNativesImpl(env);
}

}  // namespace android
}  // namespace chrome


text:
module app.identity {
    export interface IUser {
        UserName: string;
        FistName: string;
        LastName: string;
        Password: string;
        ConfirmPassword: string;
        Email: string;
        Created: string;
        Modified: string;

        PasswordEncrypted?: string;
        ConfirmPasswordEncrypted?: string;

        Url : string;

    }
}


text:
package org.apache.pinot.spi.config.table.assignment;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyDescription;
import com.google.common.base.Preconditions;
import java.util.List;
import org.apache.pinot.spi.config.BaseJsonConfig;

public class InstanceConstraintConfig extends BaseJsonConfig {

  @JsonPropertyDescription("Name of the instance constraints to be applied (mandatory)")
  private final List<String> _constraints;

  @JsonCreator
  public InstanceConstraintConfig(@JsonProperty(value = "constraints", required = true) List<String> constraints) {
    Preconditions.checkArgument(constraints != null, "'constraints' must be configured");
    _constraints = constraints;
  }

  public List<String> getConstraints() {
    return _constraints;
  }
}


text:
from __future__ import division

from auto_gen import DBWorkflow as _DBWorkflow
from id_scope import IdScope

import copy

class DBWorkflow(_DBWorkflow):

    def __init__(self, *args, **kwargs):
        _DBWorkflow.__init__(self, *args, **kwargs)
        self.objects = {}
        self.tmp_id = IdScope(1)

    def __copy__(self):
        return DBWorkflow.do_copy(self)

    def do_copy(self, new_ids=False, id_scope=None, id_remap=None):
        cp = _DBWorkflow.do_copy(self, new_ids, id_scope, id_remap)
        cp.__class__ = DBWorkflow
        # need to go through and reset the index to the copied objects
        cp.objects = {}
        for (child, _, _) in cp.db_children():
            cp.addToIndex(child)
        cp.tmp_id = copy.copy(self.tmp_id)
        return cp

    def addToIndex(self, object):
        self.objects[(object.vtType, object.getPrimaryKey())] = object

    def deleteFromIndex(self, object):
        del self.objects[(object.vtType, object.getPrimaryKey())]

    def capitalizeOne(self, str):
        return str[0].upper() + str[1:]

    def db_get_object(self, type, id):
        return self.objects[(type, id)]

    def db_add_object(self, object, parentObjType=None, parentObjId=None):
        if parentObjType is None or parentObjId is None:
            parentObj = self
        else:
            try:
                parentObj = self.objects[(parentObjType, parentObjId)]
            except KeyError:
                msg = "Cannot find object of type '%s' with id '%s'" % \
                    (parentObjType, parentObjId)
                raise Exception(msg)
        funname = 'db_add_%s' % object.vtType
        objCopy = copy.copy(object)
        getattr(parentObj, funname)(objCopy)
        self.addToIndex(objCopy)

    def db_change_object(self, object, parentObjType=None, parentObjId=None):
        if parentObjType is None or parentObjId is None:
            parentObj = self
        else:
            try:
                parentObj = self.objects[(parentObjType, parentObjId)]
            except KeyError:
                msg = "Cannot find object of type '%s' with id '%s'" % \
                    (parentObjType, parentObjId)
                raise Exception(msg)
        funname = 'db_change_%s' % object.vtType
        objCopy = copy.copy(object)
        getattr(parentObj, funname)(objCopy)
        self.addToIndex(objCopy)

    def db_delete_object(self, objId, objType,
                         parentObjType=None, parentObjId=None):
        if parentObjType is None or parentObjId is None:
            parentObj = self
        else:
            try:
                parentObj = self.objects[(parentObjType, parentObjId)]
            except KeyError:
                msg = "Cannot find object of type '%s' with id '%s'" % \
                    (parentObjType, parentObjId)
                raise Exception(msg)
        funname = 'db_get_%s' % objType
        try:
            object = getattr(parentObj, funname)(objId)
        except AttributeError:
            attr_name = 'db_%s' % objType
            object = getattr(parentObj, attr_name)
        funname = 'db_delete_%s' % objType
        getattr(parentObj, funname)(object)
        self.deleteFromIndex(object)


text:
package player

import (
	"github.com/gorilla/mux"
	"github.com/trapped/realmeye/base"
	"github.com/trapped/realmeye/db"
	"net/http"
	"strings"
	"unicode"
)

func Serve(w http.ResponseWriter, req *http.Request) {
	name := strings.TrimFunc(mux.Vars(req)["name"], func(r rune) bool {
		return unicode.IsSymbol(r) || unicode.IsSpace(r) || unicode.IsMark(r)
	})
	b := base.Page{
		Title:       "Characters of the RotMG Player: " + name,
		Location:    "/player/" + name,
		Description: "Characters of the player " + name + " in Realm of the Mad God the free online mmo rpg game.",
		Keywords:    name + ", player, characters",
	}

	if len(name) == 0 {
		tem := b.Template("player/search.gom")
		err := tem.Execute(w, b)
		if err != nil {
			panic(err)
		}
		return
	}

	p, err := db.Default.FindPlayer(name)

	b.Specific = p

	if err != nil {
		tem := b.Template("player/notfound.gom")
		err = tem.Execute(w, b)
		if err != nil {
			panic(err)
		}
		return
	}

	tem := b.Template("player/index.gom")

	err = tem.Execute(w, b)
	if err != nil {
		panic(err)
	}
}


text:
/**
 * @file    LPC214x/hal_pal_lld.c
 * @brief   LPC214x FIO low level driver code.
 *
 * @addtogroup PAL
 * @{
 */

#include "hal.h"

#if HAL_USE_PAL || defined(__DOXYGEN__)

/*===========================================================================*/
/* Driver exported variables.                                                */
/*===========================================================================*/

/*===========================================================================*/
/* Driver local variables and types.                                         */
/*===========================================================================*/

/*===========================================================================*/
/* Driver local functions.                                                   */
/*===========================================================================*/

/*===========================================================================*/
/* Driver interrupt handlers.                                                */
/*===========================================================================*/

/*===========================================================================*/
/* Driver exported functions.                                                */
/*===========================================================================*/

/**
 * @brief   LPC214x I/O ports configuration.
 * @details FIO units and PINSEL registers initialization.
 *
 * @param[in] config    the LPC214x ports configuration
 *
 * @notapi
 */
void _pal_lld_init(const PALConfig *config) {

  /* Enables the access through the fast registers.*/
  SCS = 3;

  /* I/O pads initial assignment, device drivers may change this setup at a
   * later time.*/
  PINSEL0 = config->pinsel0;
  PINSEL1 = config->pinsel1;
  PINSEL2 = config->pinsel2;

  /* I/O pads direction initial setting.*/
  FIO0Base->FIO_MASK = 0;
  FIO0Base->FIO_PIN = config->P0Data.pin;
  FIO0Base->FIO_DIR = config->P0Data.dir;
  FIO1Base->FIO_MASK = 0;
  FIO1Base->FIO_PIN = config->P1Data.pin;
  FIO1Base->FIO_DIR = config->P1Data.dir;
}

/**
 * @brief   Pads mode setup.
 * @details This function programs a pads group belonging to the same port
 *          with the specified mode.
 * @note    @p PAL_MODE_UNCONNECTED is implemented as push pull output with
 *          high state.
 * @note    This function does not alter the @p PINSELx registers. Alternate
 *          functions setup must be handled by device-specific code.
 *
 * @param[in] port      the port identifier
 * @param[in] mask      the group mask
 * @param[in] mode      the mode
 *
 * @notapi
 */
void _pal_lld_setgroupmode(ioportid_t port,
                           ioportmask_t mask,
                           iomode_t mode) {

  switch (mode) {
  case PAL_MODE_RESET:
  case PAL_MODE_INPUT:
    port->FIO_DIR &= ~mask;
    break;
  case PAL_MODE_UNCONNECTED:
    port->FIO_PIN |= mask;
  case PAL_MODE_OUTPUT_PUSHPULL:
    port->FIO_DIR |= mask;
    break;
  }
}

#endif /* HAL_USE_PAL */

/** @} */


text:
<!DOCTYPE HTML>

<title>RecoverableXAConnection (Narayana: narayana-full 5.13.1.Final API)</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="dc.created" content="2022-11-14">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery/jquery-ui.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Narayana: narayana-full 5.13.1.Final

All Classes

SEARCH:
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">

JavaScript is disabled on your browser.

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

Package com.arjuna.ats.jta.xa

Interface RecoverableXAConnection

public interface RecoverableXAConnection

XA connection implementations must provide an implementation
 of this class.

Since:

JTS 1.2.4.

Version:

$Id: RecoverableXAConnection.java 2342 2006-03-30 13:06:17Z  $

Author:

Mark Little (mark_little@hp.com)

Field Summary

Fields

Modifier and Type
Field
Description

static int
AUTO_RECOVERY

static int
OBJECT_RECOVERY

Method Summary

All Methods Instance Methods Abstract Methods

Modifier and Type
Method
Description

void
close()

void
closeCloseCurrentConnection()

javax.sql.XAConnection
getConnection()

javax.sql.XAConnection
getCurrentConnection()

javax.sql.XADataSource
getDataSource()

javax.transaction.xa.XAResource
getResource()

boolean
inuse()

boolean
packInto(OutputObjectState os)

void
reset()

boolean
setTransaction(javax.transaction.Transaction tx)

Remember the transaction we are being used within.

boolean
unpackFrom(InputObjectState os)

boolean
validTransaction(javax.transaction.Transaction tx)

Is this the same transaction?

Field Detail

AUTO_RECOVERY

static final int AUTO_RECOVERY

See Also:

Constant Field Values

OBJECT_RECOVERY

static final int OBJECT_RECOVERY

See Also:

Constant Field Values

Method Detail

packInto

boolean packInto(OutputObjectState os)

unpackFrom

boolean unpackFrom(InputObjectState os)

getResource

javax.transaction.xa.XAResource getResource()
                                     throws java.sql.SQLException

Throws:

java.sql.SQLException

getConnection

javax.sql.XAConnection getConnection()
                              throws java.sql.SQLException

Throws:

java.sql.SQLException

getCurrentConnection

javax.sql.XAConnection getCurrentConnection()
                                     throws java.sql.SQLException

Throws:

java.sql.SQLException

getDataSource

javax.sql.XADataSource getDataSource()
                              throws java.sql.SQLException

Throws:

java.sql.SQLException

closeCloseCurrentConnection

void closeCloseCurrentConnection()
                          throws java.sql.SQLException

Throws:

java.sql.SQLException

inuse

boolean inuse()

Returns:

true if the connection is being used within a transaction,
 false otherwise.

reset

void reset()

Since:

JTS 2.2.

close

void close()

Since:

JTS 2.2.

setTransaction

boolean setTransaction(javax.transaction.Transaction tx)

Remember the transaction we are being used within.

Since:

JTS 2.2.

validTransaction

boolean validTransaction(javax.transaction.Transaction tx)

Is this the same transaction?

Returns:

true if the connection can be used by this
 transaction, false otherwise.

Since:

JTS 2.2.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Narayana: narayana-full 5.13.1.Final

All Classes

JavaScript is disabled on your browser.

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

Copyright © 2022 JBoss by Red Hat. All rights reserved.