text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <base data-ice="baseUrl" href="../../../">
  <title data-ice="title">Theme | Shopify Flux API Document</title>
  <link type="text/css" rel="stylesheet" href="css/style.css">
  <link type="text/css" rel="stylesheet" href="css/prettify-tomorrow.css">

  Home
  Identifier
  Source

  Repository

    <input class="search-input">

Class

Actions

Base

BaseStore

Blog

BlogsStore

CountableStore

CountriesStore

Country

Customer

CustomersStore

Order

OrdersStore

Page

PagesStore

PoliciesStore

Policy

Product

ProductsStore

Redirect

RedirectsStore

Session

SessionStore

Shop

ShopStore

ShopifyAPIError

Theme

ThemesStore

WebAPI

Function

APIProxy

Typedef

Action

CountAction

DestroyAction

FailedRequestCallback

MergeAction

RequestPromise

ResourceQuery

SuccessfulRequestCallback

External

FluxMapStore

QueryObject

Store

  public
  class

  | source

Theme

Extends:

Base → Theme

The Theme resource

Constructor Summary

Public Constructor

      public

           constructor

Inherited Summary

 From class Base

      public

      get

           actions: Actions: *

Returns an object that supplies the clear, count and merge actions for this resource

      public

      get

           apiMethods: Array<string>: *

An array of methods to be exposed via APIProxy

      public

           clear()

Dispatches the clear action for this resource.

      public

           create(resource: object, options: object): RequestPromise

Performs a POST request, sending the resource along as the request body

      public

           destroy(id: number | string, options: object): RequestPromise

Destroys the resource

      public

           fetch(query: ResourceQuery): RequestPromise

Performs a GET request for the specified query.

      public

           fetchCount(query: ResourceQuery): RequestPromise

Performs a GET request for the resource's count endpoint

      public

           update(id: number | string, resource: object, options: object): RequestPromise

Updates the given resource

      protected

           urlFor(query: ResourceQuery, params: ResourceQuery): string

Public Constructors

    public

    constructor

      source

Override:
Base#constructor

  Generated by ESDoc(0.2.5)


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Loteria.Models.DTO
{
    public class AcertoDTO
    {
        public int? Id { get; set; }

        public int IdSorteio { get; set; }

        public int IdAposta { get; set; }

        public string NomeAcertador { get; set; }

        public string DescricaoTipoAcerto { get; set; }

        public static explicit operator Acerto(AcertoDTO tipoAcertoDTO)
        {
            var tipoAcerto = new Acerto()
            {
                Id = tipoAcertoDTO.Id.HasValue ? tipoAcertoDTO.Id.Value : -1,
                IdSorteio = tipoAcertoDTO.IdSorteio,
                IdAposta = tipoAcertoDTO.IdAposta
            };
            return tipoAcerto;
        }

        public static explicit operator AcertoDTO(Acerto tipoAcerto)
        {
            var tipoAcertoDTO = new AcertoDTO()
            {
                Id = tipoAcerto.Id,
                IdSorteio = tipoAcerto.IdSorteio,
                IdAposta = tipoAcerto.IdAposta
            };
            return tipoAcertoDTO;
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package com.uphyca.testing;

import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;

import java.util.Arrays;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import android.app.Activity;
import android.app.Instrumentation;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ResolveInfo;

import com.uphyca.testing.robolectric.MainActivity;
import com.xtremelabs.robolectric.res.RobolectricPackageManager;

@RunWith(AndroidTestRunner.class)
public class InstrumentationTestCaseTest extends InstrumentationTestCase {

    @SuppressWarnings("serial")
    private static final class Expected extends RuntimeException {
    }

    private static final String TEST_PACKAGE_NAME = "com.uphyca.testing.robolectric.test";

    private Context mContext;
    private Instrumentation mInstr;

    @Before
    public void setUp() {
        mInstr = getInstrumentation();
        mContext = mInstr.getTargetContext();

        prepareForResolveActivity();
    }

    @Test
    public void assertPreconditins() {
        assertNotNull(getInstrumentation());
        assertNotNull(getInstrumentation().getTargetContext());
        assertNotNull(getInstrumentation().getContext());
    }

    private void prepareForResolveActivity() {
        Intent intent = new Intent(Intent.ACTION_MAIN).setClassName(TEST_PACKAGE_NAME, MainActivity.class.getName());
        RobolectricPackageManager rpm = RobolectricPackageManager.class.cast(mContext.getPackageManager());

        ResolveInfo info = new ResolveInfo();

        IntentFilter filter = new IntentFilter(Intent.ACTION_MAIN);
        info.filter = filter;

        ActivityInfo activityInfo = new ActivityInfo();
        info.activityInfo = activityInfo;

        activityInfo.packageName = TEST_PACKAGE_NAME;
        activityInfo.name = MainActivity.class.getName();

        ApplicationInfo applicationInfo = new ApplicationInfo();
        activityInfo.applicationInfo = applicationInfo;

        applicationInfo.packageName = TEST_PACKAGE_NAME;

        rpm.addResolveInfoForIntent(intent, Arrays.asList(info));
    }

    @Test
    public void assertThatPrepareForResolveActivity() throws NameNotFoundException {

        Intent intent = new Intent(Intent.ACTION_MAIN).setClassName(TEST_PACKAGE_NAME, MainActivity.class.getName());
        PackageManager pm = mContext.getPackageManager();
        ComponentName component = intent.getComponent();

        assertNotNull(component);

        ActivityInfo activityInfo = pm.getActivityInfo(component, 0);

        // Robolectric doesn't implements PackageManager.getActivityInfo()
        assertNull(activityInfo);
    }

    @Test
    public void shouldLaunchActivity() {
        Activity activity = launchActivity(TEST_PACKAGE_NAME, MainActivity.class, null);
        assertNotNull(activity);
    }

    @Test(expected = Expected.class)
    public void shouldRunTestOnUiThread() throws Throwable {
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                // Notify that the task invoked.
                throw new Expected();
            }
        });
    }
}


text:
package sonar.systems.frameworks.ChartBoost;

import sonar.systems.frameworks.BaseClass.Framework;
import android.app.Activity;
import android.content.Intent;

import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

import com.chartboost.sdk.*;
import com.chartboost.sdk.Model.CBError.CBClickError;
import com.chartboost.sdk.Model.CBError.CBImpressionError;

public class ChartBoostAds extends Framework
{
	protected static final String TAG = "CHARTBOOST";
	private Activity activity;
	private String id= "";
	private String sig = "";

	public static native void rewardVideowasViewedChartboost(boolean result);
	public static native void FullscreenAdPreloaded(boolean result);

	public ChartBoostAds()
	{

	}

	@Override
	public void SetActivity(Activity activity)
	{
		this.activity = activity;

		id = activity.getResources().getString(activity.getResources().getIdentifier("chartboost_app_id","string",activity.getPackageName()));
		sig = activity.getResources().getString(activity.getResources().getIdentifier("chartboost_app_signature","string",activity.getPackageName()));
	}

	@Override
	public void onCreate(Bundle b)
	{
		 Chartboost.startWithAppId(activity, id, sig);
		 /* Optional: If you want to program responses to Chartboost events, supply a delegate object here and see step (10) for more information */
		 Chartboost.setDelegate(delegate);
		 Chartboost.onCreate(activity);

	}

	private ChartboostDelegate delegate = new ChartboostDelegate()
	{
		//Override the Chartboost delegate callbacks you wish to track and control
		 @Override
	        public boolean shouldRequestInterstitial(String location) {
	            Log.i(TAG, "SHOULD REQUEST INTERSTITIAL '"+ (location != null ? location : "null"));
	            return true;
	        }

	        @Override
	        public boolean shouldDisplayInterstitial(String location) {
	            Log.i(TAG, "SHOULD DISPLAY INTERSTITIAL '"+ (location != null ? location : "null"));
	            return true;
	        }

	        @Override
	        public void didCacheInterstitial(String location)
	        {
	            Log.i(TAG, "DID CACHE INTERSTITIAL '"+ (location != null ? location : "null"));
	            FullscreenAdPreloaded(true);
	        }

	        @Override
	        public void didFailToLoadInterstitial(String location, CBImpressionError error) {
	            Log.i(TAG, "DID FAIL TO LOAD INTERSTITIAL '"+ (location != null ? location : "null")+ " Error: " + error.name());
	            Toast.makeText(activity.getApplicationContext(), "INTERSTITIAL '"+location+"' REQUEST FAILED - " + error.name(), Toast.LENGTH_SHORT).show();
	        }

	        @Override
	        public void didDismissInterstitial(String location) {
	            Log.i(TAG, "DID DISMISS INTERSTITIAL: "+ (location != null ? location : "null"));
	        }

	        @Override
	        public void didCloseInterstitial(String location) {
	            Log.i(TAG, "DID CLOSE INTERSTITIAL: "+ (location != null ? location : "null"));
	        }

	        @Override
	        public void didClickInterstitial(String location) {
	            Log.i(TAG, "DID CLICK INTERSTITIAL: "+ (location != null ? location : "null"));
	        }

	        @Override
	        public void didDisplayInterstitial(String location) {
	            Log.i(TAG, "DID DISPLAY INTERSTITIAL: " +  (location != null ? location : "null"));
	        }

	        @Override
	        public boolean shouldRequestMoreApps(String location) {
	            Log.i(TAG, "SHOULD REQUEST MORE APPS: " +  (location != null ? location : "null"));
	            return true;
	        }

	        @Override
	        public boolean shouldDisplayMoreApps(String location) {
	            Log.i(TAG, "SHOULD DISPLAY MORE APPS: " +  (location != null ? location : "null"));
	            return true;
	        }

	        @Override
	        public void didFailToLoadMoreApps(String location, CBImpressionError error) {
	            Log.i(TAG, "DID FAIL TO LOAD MOREAPPS " +  (location != null ? location : "null")+ " Error: "+ error.name());
	            Toast.makeText(activity.getApplicationContext(), "MORE APPS REQUEST FAILED - " + error.name(), Toast.LENGTH_SHORT).show();
	        }

	        @Override
	        public void didCacheMoreApps(String location) {
	            Log.i(TAG, "DID CACHE MORE APPS: " +  (location != null ? location : "null"));
	        }

	        @Override
	        public void didDismissMoreApps(String location) {
	            Log.i(TAG, "DID DISMISS MORE APPS " +  (location != null ? location : "null"));
	        }

	        @Override
	        public void didCloseMoreApps(String location) {
	            Log.i(TAG, "DID CLOSE MORE APPS: "+  (location != null ? location : "null"));
	        }

	        @Override
	        public void didClickMoreApps(String location) {
	            Log.i(TAG, "DID CLICK MORE APPS: "+  (location != null ? location : "null"));
	        }

	        @Override
	        public void didDisplayMoreApps(String location) {
	            Log.i(TAG, "DID DISPLAY MORE APPS: " +  (location != null ? location : "null"));
	        }

	        @Override
	        public void didFailToRecordClick(String uri, CBClickError error) {
	            Log.i(TAG, "DID FAILED TO RECORD CLICK " + (uri != null ? uri : "null") + ", error: " + error.name());
	            Toast.makeText(activity.getApplicationContext(), "FAILED TO RECORD CLICK " + (uri != null ? uri : "null") + ", error: " + error.name(), Toast.LENGTH_SHORT).show();
	        }

	        @Override
	        public void didDismissRewardedVideo(String location) {
	            Log.i(TAG, String.format("DID DISMISS REWARDED VIDEO '%s'",  (location != null ? location : "null")));
	        }

	        @Override
	        public void didCloseRewardedVideo(String location) {
	            Log.i(TAG, String.format("DID CLOSE REWARDED VIDEO '%s'",  (location != null ? location : "null")));
	        }

	        @Override
	        public void didClickRewardedVideo(String location)
	        {
	            Log.i(TAG, String.format("DID CLICK REWARDED VIDEO '%s'",  (location != null ? location : "null")));
	        }

	        @Override
	        public void didCompleteRewardedVideo(String location, int reward)
	        {
	            Log.i(TAG, String.format("DID COMPLETE REWARDED VIDEO '%s' FOR REWARD %d",  (location != null ? location : "null"), reward));
	            rewardVideowasViewedChartboost(true);
	        }

	        @Override
	        public void didDisplayRewardedVideo(String location)
	        {
	            Log.i(TAG, String.format("DID DISPLAY REWARDED VIDEO: '%s'",  (location != null ? location : "null")));
	        }

	};

	@Override
	public boolean onBackPressed()
	{
		 if (Chartboost.onBackPressed())
		        return true;
		    else
		        return false;
	}

	@Override
	public void onStart()
	{
		Chartboost.onStart(activity);
	}

	@Override
	public void onStop()
	{
		 Chartboost.onStop(activity);
	}

	@Override
	public void onPause()
	{
		Chartboost.onPause(activity);
	}

	@Override
	public void onActivityResult(int request, int response, Intent data)
	{

	}

	@Override
	public void onResume()
	{
		Chartboost.onResume(activity);

	}

	@Override
	public void onDestroy()
	{
		Chartboost.onDestroy(activity);

	}

	@Override
	public void ShowFullscreenAd()
	{
		Chartboost.showInterstitial(CBLocation.LOCATION_DEFAULT);
	}

	@Override
	public void ShowVideoAd()
	{
		Chartboost.showRewardedVideo(CBLocation.LOCATION_DEFAULT);
	}

	@Override
	public void PreLoadFullscreenAd()
	{
		Chartboost.cacheInterstitial(CBLocation.LOCATION_DEFAULT);
	}

	@Override
	public void PreLoadVideoAd()
	{
		Chartboost.cacheRewardedVideo(CBLocation.LOCATION_DEFAULT);
	}

}


text:
<?php
function zKillRedis()
{
    try {
        // Initialize a new request for this URL
        $ch = curl_init("http://redisq.zkillboard.com/listen.php");
        // Set the options for this request
        curl_setopt_array($ch, array(
            CURLOPT_FOLLOWLOCATION => true, // Yes, we want to follow a redirect
            CURLOPT_RETURNTRANSFER => true, // Yes, we want that curl_exec returns the fetched data
            CURLOPT_TIMEOUT => 8,
            CURLOPT_SSL_VERIFYPEER => true, // Do not verify the SSL certificate
        ));
        // Fetch the data from the URL
        $data = curl_exec($ch);
        // Close the connection
        curl_close($ch);
        $data = json_decode($data, TRUE);

    } catch (Exception $e) {
        return null;
    }
    return $data['package'];
}

function getStartMail($kmGroup)
{
    if ($kmGroup['allianceID'] === '0' && $kmGroup['lossMails'] === 'true' && $kmGroup['corpID'] !== '0') {
        $url = "https://zkillboard.com/api/no-attackers/no-items/corporationID/{$kmGroup['corpID']}/limit/1/";
    }
    if ($kmGroup['allianceID'] === '0' && $kmGroup['lossMails'] === 'false' && $kmGroup['corpID'] !== '0') {
        $url = "https://zkillboard.com/api/no-attackers/no-items/kills/corporationID/{$kmGroup['corpID']}/limit/1/";
    }
    if ($kmGroup['allianceID'] !== '0' && $kmGroup['lossMails'] === 'true' && $kmGroup['allianceID'] !== '0') {
        $url = "https://zkillboard.com/api/no-attackers/no-items/allianceID/{$kmGroup['allianceID']}/limit/1/";
    }
    if ($kmGroup['allianceID'] !== '0' && $kmGroup['lossMails'] === 'false' && $kmGroup['allianceID'] !== '0') {
        $url = "https://zkillboard.com/api/no-attackers/no-items/kills/allianceID/{$kmGroup['allianceID']}/limit/1/";
    }

    if (!isset($url)) { // Make sure it's always set.
        return null;
    }

    $kill = json_decode(downloadData($url), true);
    if (null !== $kill) {
        foreach ($kill as $mail) {
            $killID = $mail['killID'];
            setPermCache("{$kmGroup['name']}newestKillmailID", $killID);
        }
    }
}

function getStartBigMail()
{
    $url = 'https://zkillboard.com/api/kills/orderDirection/desc/iskValue/10000000000/';

    if (!isset($url)) { // Make sure it's always set.
        return null;
    }

    $kill = json_decode(downloadData($url), true);
    if (null !== $kill) {
        foreach ($kill as $mail) {
            $killID = $mail['killID'];
            setPermCache('bigKillNewestKillmailID', $killID);
        }
    }
}


text:
const {assert} = chai;

import {assertNotNullOrUndefined} from '../../../../../front_end/core/platform/platform.js';
import * as SDK from '../../../../../front_end/core/sdk/sdk.js';
import * as UI from '../../../../../front_end/ui/legacy/legacy.js';
import * as Main from '../../../../../front_end/entrypoints/main/main.js';
import {createTarget, stubNoopSettings} from '../../helpers/EnvironmentHelpers.js';

import {
  describeWithMockConnection,
} from '../../helpers/MockConnection.js';

describeWithMockConnection('MainMenuItem', () => {
  const focusDebuggee = (targetFactory: () => SDK.Target.Target) => {
    beforeEach(async () => {
      stubNoopSettings();
      sinon.stub(UI.ShortcutRegistry.ShortcutRegistry, 'instance').returns({
        shortcutTitleForAction: () => {},
        shortcutsForAction: () => [],
      } as unknown as UI.ShortcutRegistry.ShortcutRegistry);
      targetFactory();
    });

    it('includes focus debuggee item when undocked', async () => {
      UI.DockController.DockController.instance().setDockSide(UI.DockController.DockState.UNDOCKED);

      const item = Main.MainImpl.MainMenuItem.instance({forceNew: true}).item() as UI.Toolbar.ToolbarMenuButton;
      assertNotNullOrUndefined(item);

      const contextMenuShow = sinon.stub(UI.ContextMenu.ContextMenu.prototype, 'show').resolves();
      sinon.stub(UI.ActionRegistry.ActionRegistry.instance(), 'action')
          .withArgs(sinon.match(/inspector_main.focus-debuggee|main.toggle-drawer/))
          .returns({execute: () => {}} as UI.ActionRegistration.Action);
      item.clicked(new MouseEvent('click', {
        bubbles: true,
        cancelable: true,
      }));

      assert.isTrue(contextMenuShow.calledOnce);
      assert.exists(contextMenuShow.thisValues[0].defaultSection().items.find(
          (item: UI.ContextMenu.Item) => item.buildDescriptor().label === 'Focus debuggee'));
    });

    it('does not include focus debuggee item when docked', async () => {
      UI.DockController.DockController.instance().setDockSide(UI.DockController.DockState.BOTTOM);

      const item = Main.MainImpl.MainMenuItem.instance({forceNew: true}).item() as UI.Toolbar.ToolbarMenuButton;
      assertNotNullOrUndefined(item);

      const contextMenuShow = sinon.stub(UI.ContextMenu.ContextMenu.prototype, 'show').resolves();
      sinon.stub(UI.ActionRegistry.ActionRegistry.instance(), 'action').withArgs('main.toggle-drawer').returns({
        execute: () => {},
      } as UI.ActionRegistration.Action);
      item.clicked(new MouseEvent('click', {
        bubbles: true,
        cancelable: true,
      }));

      assert.isTrue(contextMenuShow.calledOnce);
      assert.notExists(contextMenuShow.thisValues[0].defaultSection().items.find(
          (item: UI.ContextMenu.Item) => item.buildDescriptor().label === 'Focus debuggee'));
    });
  };
  describe('without tab target', () => focusDebuggee(() => createTarget()));
  describe('with tab target', () => focusDebuggee(() => {
                                const tabTaget = createTarget({type: SDK.Target.Type.Tab});
                                createTarget({parentTarget: tabTaget, subtype: 'prerender'});
                                return createTarget({parentTarget: tabTaget});
                              }));
});


text:
'use strict';

exports.__esModule = true;

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var _invariant = require('invariant');

var _invariant2 = _interopRequireDefault(_invariant);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _RouteUtils = require('./RouteUtils');

var _PropTypes = require('./PropTypes');

var _React$PropTypes = _react2['default'].PropTypes;
var string = _React$PropTypes.string;
var bool = _React$PropTypes.bool;
var func = _React$PropTypes.func;

/**
 * A <Route> is used to declare which components are rendered to the
 * page when the URL matches a given pattern.
 *
 * Routes are arranged in a nested tree structure. When a new URL is
 * requested, the tree is searched depth-first to find a route whose
 * path matches the URL.  When one is found, all routes in the tree
 * that lead to it are considered "active" and their components are
 * rendered into the DOM, nested in the same order as in the tree.
 */

var Route = (function (_Component) {
  _inherits(Route, _Component);

  function Route() {
    _classCallCheck(this, Route);

    _Component.apply(this, arguments);
  }

  /* istanbul ignore next: sanity check */

  Route.prototype.render = function render() {
    !false ? process.env.NODE_ENV !== 'production' ? _invariant2['default'](false, '<Route> elements are for router configuration only and should not be rendered') : _invariant2['default'](false) : undefined;
  };

  _createClass(Route, null, [{
    key: 'createRouteFromReactElement',
    value: _RouteUtils.createRouteFromReactElement,
    enumerable: true
  }, {
    key: 'propTypes',
    value: {
      path: string,
      ignoreScrollBehavior: bool,
      component: _PropTypes.component,
      components: _PropTypes.components,
      getComponents: func
    },
    enumerable: true
  }]);

  return Route;
})(_react.Component);

exports['default'] = Route;
module.exports = exports['default'];


text:
namespace swift {

class RCIdentityFunctionInfo;
class ConsumedArgToEpilogueReleaseMatcher;

} // end swift namespace

//===----------------------------------------------------------------------===//
//                           RCStateTransitionKind
//===----------------------------------------------------------------------===//

namespace swift {

/// The kind of a RCStateTransition.
enum class RCStateTransitionKind : uint8_t {
#define KIND(K) K,
#define ABSTRACT_VALUE(Name, StartKind, EndKind) \
  Name ## _Start = StartKind, Name ## _End = EndKind,
#include "RCStateTransition.def"
};

/// \returns the RCStateTransitionKind corresponding to \p V.
RCStateTransitionKind getRCStateTransitionKind(ValueBase *V);

/// Define predicates to test for RCStateTransition abstract value kinds.
#define ABSTRACT_VALUE(Name, Start, End)                              \
  bool isRCStateTransition ## Name(RCStateTransitionKind Kind);       \
  static inline bool isRCStateTransition ## Name(ValueBase *V) {      \
    return isRCStateTransition ## Name(getRCStateTransitionKind(V));  \
  }
#define KIND(Name)                                                      \
  static inline bool isRCStateTransition ## Name(ValueBase *V) {        \
    return RCStateTransitionKind::Name == getRCStateTransitionKind(V);  \
  }
#include "RCStateTransition.def"

//===----------------------------------------------------------------------===//
//                             RCStateTransition
//===----------------------------------------------------------------------===//

class RefCountState;

/// Represents a transition in the RC history of a ref count.
class RCStateTransition {
  friend class RefCountState;

  /// An RCStateTransition can represent either an RC end point (i.e. an initial
  /// or terminal RC transition) or a ptr set of Mutators.
  ValueBase *EndPoint;
  llvm::SmallPtrSet<SILInstruction *, 2> Mutators;
  RCStateTransitionKind Kind;

  // Should only be constructed be default RefCountState.
  RCStateTransition() {}

public:
  ~RCStateTransition() {}
  RCStateTransition(const RCStateTransition &R);

  RCStateTransition(SILInstruction *I) {
    Kind = getRCStateTransitionKind(I);
    if (isRCStateTransitionEndPoint(Kind)) {
      EndPoint = I;
      return;
    }

    if (isRCStateTransitionMutator(Kind)) {
      Mutators.insert(I);
      return;
    }

    // Unknown kind.
  }

  RCStateTransition(SILArgument *A)
      : EndPoint(A), Kind(RCStateTransitionKind::StrongEntrance) {
    assert(A->hasConvention(ParameterConvention::Direct_Owned) &&
           "Expected owned argument");
  }

  RCStateTransitionKind getKind() const { return Kind; }

/// Define test functions for the various abstract categorizations we have.
#define ABSTRACT_VALUE(Name, StartKind, EndKind) bool is ## Name() const;
#include "RCStateTransition.def"

  /// Return true if this Transition is a mutator transition that contains I.
  bool containsMutator(SILInstruction *I) const {
    assert(isMutator() && "This should only be called if we are of mutator "
                          "kind");
    return Mutators.count(I);
  }

  using mutator_range = iterator_range<decltype(Mutators)::iterator>;
  using const_mutator_range = iterator_range<decltype(Mutators)::const_iterator>;

  /// Returns a Range of Mutators. Asserts if this transition is not a mutator
  /// transition.
  mutator_range getMutators() const {
    assert(isMutator() && "This should never be called given mutators");
    return {Mutators.begin(), Mutators.end()};
  }

  /// Return true if Inst is an instruction that causes a transition that can be
  /// paired with this transition.
  bool matchingInst(SILInstruction *Inst) const;

  /// Attempt to merge \p Other into \p this. Returns true if we succeeded,
  /// false otherwise.
  bool merge(const RCStateTransition &Other);
};

} // end swift namespace

namespace llvm {
raw_ostream &operator<<(raw_ostream &os, swift::RCStateTransitionKind Kind);
} // end llvm namespace

#endif


text:
int tock_u2f_check(void);
// Transmit as a frame from U2F endpoint. datalen must be <= 64.
int tock_u2f_transmit(void* data, size_t datalen);
// Receive a frame from U2F endopint. datalen must be <= 64.
int tock_u2f_receive(void* data, size_t datalen);

// Low-level chip accesses
uint32_t tock_chip_dev_id0(void);
uint32_t tock_chip_dev_id1(void);
int tock_chip_category(void);

// Robust counter
unsigned int increment_counter(void);

enum touch_state {
  POP_TOUCH_NO  = 0,
  POP_TOUCH_YES = 1,
};

void tock_pop_enable_detection(void);
void tock_pop_set(void);
void tock_pop_clear(void);
enum touch_state tock_pop_check_presence(int consume);

#endif


text:
#include <mcheck.h>
#include <softdsp/primitive.hpp>
#include <softdsp/constant_generator.hpp>
#include <softdsp/tag.hpp>
#include <softdsp/type_generator.hpp>
#include <softdsp/nth_type.hpp>
#include <softdsp/data_layout/load_value_at.hpp>
#include <softdsp/data_layout/store_value_at.hpp>
#include <softdsp/data_layout/common.hpp>
#include <softdsp/data_layout/proxy.hpp>
#include <softdsp/data_layout/get_element_type.hpp>
#include <softdsp/data_layout/array.hpp>
#include <softdsp/data_layout/tuple.hpp>
#include <softdsp/placeholders.hpp>
#include <softdsp/llvm_toolbox.hpp>
#include <softdsp/context.hpp>
#include <softdsp/static_cast.hpp>
#include <softdsp/value_generator.hpp>

#include <llvm/ADT/ArrayRef.h>
#include <llvm/LLVMContext.h>
#include <llvm/Module.h>
#include <llvm/Function.h>
#include <llvm/BasicBlock.h>
#include <llvm/Support/IRBuilder.h>
#include <llvm/DataLayout.h>
#include <llvm/Support/TargetSelect.h>
#include <llvm/Target/TargetOptions.h>
#include <llvm/Target/TargetMachine.h>
#include <llvm/Support/TargetRegistry.h>
#include <llvm/Support/raw_ostream.h>
#include <llvm/DerivedTypes.h>
#include <llvm/Transforms/Utils/Cloning.h>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/ExecutionEngine/GenericValue.h>
#include <llvm/ExecutionEngine/JIT.h>
#include <llvm/ExecutionEngine/JITEventListener.h>
#include <llvm/ExecutionEngine/MCJIT.h>
#include <llvm/Support/IRReader.h>
#include <llvm/Support/SourceMgr.h>

#include <array>
#include <memory>
#include <vector>
#include <string>
#include <boost/range/algorithm.hpp>
#include <boost/range/reference.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits.hpp>
#include <boost/bind.hpp>
#include <boost/array.hpp>
#include <boost/fusion/algorithm.hpp>
#include <boost/fusion/include/boost_array.hpp>
#include <boost/fusion/include/copy.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/fusion/include/make_vector.hpp>
#include <boost/fusion/adapted/adt/adapt_adt.hpp>
#include <boost/fusion/mpl.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/preprocessor/enum.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/tuple/enum.hpp>
#include <boost/preprocessor/tuple/to_seq.hpp>
#include <boost/preprocessor/seq/transform.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/swap.hpp>
#include <boost/proto/proto.hpp>
#include <boost/container/flat_map.hpp>
#include <boost/function_types/function_pointer.hpp>
#include <boost/function_types/components.hpp>

#include <hermit/range_traits.hpp>
#include <softdsp/static_range_size.hpp>

#include <cxxabi.h>

namespace softdsp {

  template< typename function_type >
  class function {
  public:
    function(
      const std::shared_ptr< llvm::LLVMContext > &context_,
      const std::shared_ptr< llvm::EngineBuilder > builder_,
      const std::shared_ptr< llvm::ExecutionEngine > engine_,
      llvm::Function *entry_point_
    ) : context( context_ ), builder( builder_ ), engine( engine_ ), entry_point( entry_point_ ) {
    }
    int operator()( const data_layout::array< int, 2 > &value, const softdsp::data_layout::tuple< int, double, int, int > &value2, const data_layout::array< data_layout::array< int, 2 >, 2 > &value3 ) {
      //return reinterpret_cast< typename boost::function_types::function_pointer< boost::function_types::components< function_type > >::type >( engine->getPointerToFunction( entry_point ) )( value );
      return reinterpret_cast< int(*)( const void*, const void*, const void* ) >( engine->getPointerToFunction( entry_point ) )( value.get(), value2.get(), value3.get() );
    }
  private:
    const std::shared_ptr< llvm::LLVMContext > context;
    const std::shared_ptr< llvm::EngineBuilder > builder;
    const std::shared_ptr< llvm::ExecutionEngine > engine;
    llvm::Function *entry_point;
  };

  class executable {
  public:
    executable(
      const std::shared_ptr< llvm::LLVMContext > &context_,
      const std::shared_ptr< llvm::Module > &llvm_module_
    ) : context( context_ ), llvm_module( llvm::CloneModule( llvm_module_.get() ) ) {
      llvm::EngineBuilder *engine_builder = new llvm::EngineBuilder( llvm_module );
      std::shared_ptr< std::string > error_message( new std::string );
      engine_builder->setErrorStr( error_message.get() );
      engine_builder->setEngineKind( llvm::EngineKind::JIT );
      engine_builder->setOptLevel( llvm::CodeGenOpt::Aggressive );
      engine.reset( engine_builder->create() );
      if (!engine) {
        delete engine_builder;
        if (!error_message->empty())
          llvm::errs() << "dcompile::module" << ": error creating EE: " << *error_message << "\n";
        else
          llvm::errs() << "dcompile::module" << ": unknown error creating EE!\n";
        throw -1;
      }
      builder.reset( engine_builder, boost::bind( &executable::deleteBuilder, ::_1, engine, error_message ) );
      builder->setRelocationModel(llvm::Reloc::Default);
      builder->setCodeModel( llvm::CodeModel::JITDefault );
      builder->setUseMCJIT(true);
      engine->RegisterJITEventListener(llvm::JITEventListener::createOProfileJITEventListener());
      engine->DisableLazyCompilation(true);
      engine->runStaticConstructorsDestructors(false);
    }
    template< typename function_type >
    function< function_type > get_function( const std::string &name ) const {
      llvm::Function *entry_point = llvm_module->getFunction( name.c_str() );
      if( !entry_point )
        throw -1;
      return function< function_type >( context, builder, engine, entry_point );
    }
  private:
    static void deleteBuilder(
        llvm::EngineBuilder *builder,
        std::shared_ptr< llvm::ExecutionEngine > engine,
        std::shared_ptr< std::string >
      ) {
      engine->runStaticConstructorsDestructors(true);
      delete builder;
    }
    const std::shared_ptr< llvm::LLVMContext > context;
    const std::shared_ptr< llvm::Module > cloned_module;
    std::shared_ptr< llvm::EngineBuilder > builder;
    std::shared_ptr< llvm::ExecutionEngine > engine;
    llvm::Module *llvm_module;
  };

  class module {
  public:
    module(
      const std::shared_ptr< llvm::LLVMContext > &context_,
      const std::string &name_,
      const std::string &data_layout
    ) : llvm_context( context_ ),
        llvm_module( new llvm::Module( name_.c_str(), *llvm_context ) ) {
      llvm_module->setDataLayout( data_layout );
    }
    template < typename function_type, typename Expr >
    void add_function( const std::string name_, Expr &expr ) {
      std::shared_ptr< softdsp::llvm_toolbox< function_type > > tools( new softdsp::llvm_toolbox< function_type >( llvm_context, name_.c_str() ) );
      softdsp_context< function_type > context( tools );
      llvm_module->getFunctionList().push_back( tools->llvm_function );
      const auto result = boost::proto::eval( expr, context );
      result.value->getType()->dump();
      tools->ir_builder.CreateRet(
        tools->as_llvm_value(
          tools->load( result )
        ).value
      );
    }
    void dump() const {
      llvm_module->dump();
    }
    executable compile() const {
      return executable( llvm_context, llvm_module );
    }
  private:
    const std::shared_ptr< llvm::LLVMContext > llvm_context;
    const std::shared_ptr< llvm::Module > llvm_module;
  };

}
int main() {
  using namespace softdsp;
  std::shared_ptr< llvm::LLVMContext > context( new llvm::LLVMContext() );
  llvm::Module *module = new llvm::Module( "foo_bar", *context );
  llvm::IRBuilder<> builder( *context );
/*
  std::vector< llvm::Type* > args_raw( 2 );
  args_raw[ 0 ] = static_cast< llvm::Type* >( llvm::VectorType::get( builder.getFloatTy(), 4 ) );
  args_raw[ 1 ] = static_cast< llvm::Type* >( llvm::VectorType::get( builder.getFloatTy(), 4 ) );
  llvm::ArrayRef< llvm::Type* > args( args_raw );

  constant_generator gen( context );

  std::vector< float > const_vec = { 0.0f, 0.1f, 0.2f, 0.3f };
  llvm::Constant *const_vec_as_llvm = gen( const_vec );
  std::vector< int > const_int_vec = { 0, 1, 2, 3 };
  llvm::Constant *const_int_vec_as_llvm = gen( const_int_vec );
  auto const_int_vec_fp = builder.CreateSIToFP(
    const_int_vec_as_llvm,
    const_vec_as_llvm->getType()
  );

  const auto const_struct = boost::fusion::make_vector( 5, 'a', boost::fusion::make_vector( 1.0f, 3 ) );
  llvm::Constant *const_struct_as_llvm = gen( const_struct );
  type_generator ct( context );
  llvm::Type *a_type = ct( tag< boost::fusion::vector< int, std::array< float, 5 >, double > >() );
  llvm::DataLayout dl( module );
  std::cout << dl.getTypeStoreSize( a_type ) << std::endl;
  llvm::FunctionType *func1t =
    llvm::FunctionType::get( a_type, false );
  llvm::Function *func1 =
    llvm::Function::Create( func1t, llvm::Function::ExternalLinkage, "foo", module );
  builder.SetInsertPoint(
    llvm::BasicBlock::Create( *context, "foo", func1 )
  );
  //builder.CreateRet( const_struct_as_llvm );

  llvm::FunctionType *func2t =
    llvm::FunctionType::get( llvm::VectorType::get( builder.getFloatTy(), 4 ), args, false );
  llvm::Function *func2 =
    llvm::Function::Create( func2t, llvm::Function::ExternalLinkage );
  module->getFunctionList().push_back( func2 );
  builder.SetInsertPoint(
    llvm::BasicBlock::Create( *context, "entrypoint", func2 )
  );

  auto &arg_values = func2->getArgumentList();
  //auto result = llvm::BinaryOperator::Create(
  //  llvm::Instruction::FAdd,
  //  static_cast< llvm::Value* >( &arg_values.front() ),
  //  static_cast< llvm::Value* >( &arg_values.back() )
  //);
  auto result = builder.CreateFAdd(
    static_cast< llvm::Value* >( &arg_values.front() ),
    static_cast< llvm::Value* >( &arg_values.back() ) );
  auto result2 = builder.CreateFAdd(
    static_cast< llvm::Value* >( result ),
    static_cast< llvm::Value* >( const_vec_as_llvm ) );
  auto result3 = builder.CreateFAdd(
    static_cast< llvm::Value* >( result2 ),
    static_cast< llvm::Value* >( const_int_vec_fp ) );
  builder.CreateRet( result3 );
  module->dump();

  llvm::InitializeNativeTarget();
  std::string error;
  const llvm::Target * const target = llvm::TargetRegistry::lookupTarget( "x86_64-pc-linux", error );
  if( !error.empty() ) {
    std::cout << error << std::endl;
  }
  llvm::TargetOptions target_opts;
  target_opts.UseInitArray = 0;
  target_opts.UseSoftFloat = 0;
  target_opts.FloatABIType = llvm::FloatABI::Hard;
  const std::shared_ptr< llvm::TargetMachine > target_machine( target->createTargetMachine( "x86_64-pc-linux", "core2", "", target_opts ) );
  if( !target_machine ) {
    std::cout << "unable to create target machine." << std::endl;
  }
  const llvm::DataLayout *target_data = target_machine->getDataLayout();
  module->setTargetTriple( "x86_64-pc-linux" );
  module->setDataLayout( target_data->getStringRepresentation() );
  std::cout << module->getDataLayout() << std::endl;

  value_generator vg( context, module->getDataLayout() );
  auto dl0 = vg( tag< data_layout::tuple< int, data_layout::array< data_layout::tuple< int, double >, 20 >, float > >() );
//  data_layout::tuple< int, data_layout::array< data_layout::tuple< int, double >, 20 >, float > dl0( context, module->getDataLayout() );
  int status;
  boost::fusion::at_c< 0 >( boost::fusion::at_c< 1 >( dl0 ).at( 0 ) ) = 1;
  std::cout << boost::fusion::at_c< 0 >( boost::fusion::at_c< 1 >( dl0 ).at( 0 ) ) << std::endl;
  boost::fusion::at_c< 2 >( dl0 ) = 0.5f;
  std::cout << boost::fusion::at_c< 2 >( dl0 ) << std::endl;

  std::shared_ptr< softdsp::llvm_toolbox< int ( softdsp::data_layout::array< int, 5 > ) > > tools( new softdsp::llvm_toolbox< int ( softdsp::data_layout::array< int, 5 > ) >( context, "foo" ) );
  softdsp_context< int ( softdsp::data_layout::array< int, 5 > ) > sd_context( tools );
  module->getFunctionList().push_back( tools->llvm_function );
  tools->ir_builder.CreateRet( boost::proto::eval( proto::lit( 5 ) + 3 - 1 + softdsp::_1[ 1 ], sd_context ).value );
  module->dump();

  const auto roo = ct( tag< softdsp::data_layout::array< int, 5 > >() );
  roo->dump();
  const auto doo = ct( tag< std::array< int, 5 > >() );
  doo->dump();

  {
    softdsp::module sd_module( context, "the_module", target_data->getStringRepresentation() );
    sd_module.add_function< int ( softdsp::data_layout::array< int, 5 > ) >(
      "woo",
      proto::lit( 5 ) + 3 - 1 + softdsp::_1[ 1 ]
    );
    sd_module.dump();
    const auto executable = sd_module.compile();
  }*/
  {
  llvm::InitializeNativeTarget();
  std::string error;
  const llvm::Target * const target = llvm::TargetRegistry::lookupTarget( "x86_64-pc-linux", error );
  if( !error.empty() ) {
    std::cout << error << std::endl;
  }
  llvm::TargetOptions target_opts;
  target_opts.UseInitArray = 0;
  target_opts.UseSoftFloat = 0;
  target_opts.FloatABIType = llvm::FloatABI::Hard;
  const std::shared_ptr< llvm::TargetMachine > target_machine( target->createTargetMachine( "x86_64-pc-linux", "core2", "", target_opts ) );
  if( !target_machine ) {
    std::cout << "unable to create target machine." << std::endl;
  }
  const auto foo = proto::lit( 10 ) + 0;
  const llvm::DataLayout *target_data = target_machine->getDataLayout();
  module->setTargetTriple( "x86_64-pc-linux" );
  module->setDataLayout( target_data->getStringRepresentation() );
    softdsp::module sd_module( context, "the_module", target_data->getStringRepresentation() );
    sd_module.add_function< int ( softdsp::data_layout::array< int, 2 >, softdsp::data_layout::tuple< int, double, int, int >, softdsp::data_layout::array< softdsp::data_layout::array< int, 2 >, 2 > ) >(
      "woo",
      (
        softdsp::_1[ 0 ] <<= 20,
        softdsp::_1[ 1 ] = ( softdsp::static_cast_< int32_t >( softdsp::static_cast_< float >( softdsp::_1[ 0 ] ) * 3 + ++--softdsp::at_c< 2 >( softdsp::_2 ) / 3 ) + ( ~softdsp::_3[ 1 ][ 1 ] << 1 ) ) % 6
      )
    );
    sd_module.dump();
    value_generator vg( context, module->getDataLayout() );
    auto arg1 = vg( tag< softdsp::data_layout::array< int, 2 > >() );
    arg1[ 0 ] = 1;
    arg1[ 1 ] = 2;
    auto arg2 = vg( tag< softdsp::data_layout::tuple< int, double, int, int > >() );
    boost::fusion::at_c< 0 >( arg2 ) = 4;
    boost::fusion::at_c< 1 >( arg2 ) = 5.0;
    boost::fusion::at_c< 2 >( arg2 ) = 8;
    boost::fusion::at_c< 3 >( arg2 ) = 20;
    auto arg3 = vg( tag< softdsp::data_layout::array< softdsp::data_layout::array< int, 2 >, 2 > >() );
    arg3[ 0 ][ 0 ] = 1;
    arg3[ 0 ][ 1 ] = 2;
    arg3[ 1 ][ 0 ] = 3;
    arg3[ 1 ][ 1 ] = 4;
    const auto executable = sd_module.compile();
    auto function = executable.get_function< int ( softdsp::data_layout::array< int, 2 >, softdsp::data_layout::tuple< int, double, int, int >, softdsp::data_layout::array< softdsp::data_layout::array< int, 2 >, 2 > ) >( "woo" );
    std::cout << function( arg1,arg2,arg3 ) << std::endl;
  }
}


text:
import Vue from 'vue';
import VueRouter from 'vue-router';
import AboutPage from './components/AboutPage.vue';
import DatasetsPage from './components/DatasetsPage.vue';
Vue.use(VueRouter);

const router = new VueRouter({
  routes: [
    { path: '/', redirect: '/about' },
    { path: '/annotations', component: async () => await import(/* webpackPrefetch: true, webpackChunkName: "AnnotationsPage" */ './components/AnnotationsPage.vue') },
    {
      path: '/datasets',
      component: DatasetsPage,
      children: [
        {path: '', redirect: 'list'},
        {path: 'list', component: async () => await import(/* webpackPrefetch: true, webpackChunkName: "DatasetTable" */ './components/DatasetTable.vue')},
        {path: 'summary', component: async () => await import(/* webpackPrefetch: true, webpackChunkName: "DatasetSummary" */ './components/plots/DatasetSummary.vue')},
      ]
    },

    {
      path: '/datasets/edit/:dataset_id',
      component: async () => await import(/* webpackPrefetch: true, webpackChunkName: "MetadataEditPage" */ './components/MetadataEditPage.vue'),
      name: 'edit-metadata'
    },
    {
      path: '/datasets/:dataset_id/add-optical-image',
      name: 'add-optical-image',
      component: async () => await import(/* webpackPrefetch: true, webpackChunkName: "ImageAlignmentPage" */ './components/ImageAlignmentPage.vue')
    },
    {
      path: '/upload',
      component: async () => await import(/* webpackPrefetch: true, webpackChunkName: "UploadPage" */ './components/UploadPage.vue')
    },
    { path: '/about', component: AboutPage },
    { path: '/help', component: async () => await import(/* webpackPrefetch: true, webpackChunkName: "HelpPage" */ './components/HelpPage.vue') }
  ]
})

export default router;


text:
#!/bin/bash
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.

set -e -x

BUILD_DEVICE="CPU"
BUILD_CONFIG="Release"
while getopts "d:" parameter_Option
do case "${parameter_Option}"
in
#GPU or CPU.
d) BUILD_DEVICE=${OPTARG};;
esac
done

cd $BUILD_BINARIESDIRECTORY
files=(whl/*.whl)
FILE_NAME="${files[0]}"
FILE_NAME=$(basename $FILE_NAME)
PYTHON_PACKAGE_NAME=$(echo "$FILE_NAME" | cut -f 1 -d '-')

echo "Package name:$PYTHON_PACKAGE_NAME"

BUILD_ARGS="--build_dir $BUILD_BINARIESDIRECTORY --config $BUILD_CONFIG --test --skip_submodule_sync --parallel --enable_lto --build_wheel "

if [ $ARCH == "x86_64" ]; then
    #ARM build machines do not have the test data yet.
    BUILD_ARGS="$BUILD_ARGS --enable_onnx_tests"
fi
if [ $BUILD_DEVICE == "GPU" ]; then
    BUILD_ARGS="$BUILD_ARGS --use_cuda --use_tensorrt --cuda_version=11.6 --tensorrt_home=/usr --cuda_home=/usr/local/cuda-11.6 --cudnn_home=/usr/local/cuda-11.6"
fi
# We assume the machine doesn't have gcc and python development header files, so we don't build onnxruntime from source
sudo rm -rf /build /onnxruntime_src
sudo ln -s $BUILD_SOURCESDIRECTORY /onnxruntime_src
python3 -m pip uninstall -y $PYTHON_PACKAGE_NAME ort-nightly-gpu ort-nightly onnxruntime onnxruntime-gpu onnxruntime-training onnxruntime-directml ort-nightly-directml onnx -qq
cp $BUILD_SOURCESDIRECTORY/tools/ci_build/github/linux/docker/scripts/manylinux/requirements.txt $BUILD_BINARIESDIRECTORY/requirements.txt
# Test ORT with the latest ONNX release.
sed -i "s/git+http:\/\/github\.com\/onnx\/onnx.*/onnx/" $BUILD_BINARIESDIRECTORY/requirements.txt
python3 -m pip install -r $BUILD_BINARIESDIRECTORY/requirements.txt
python3 -m pip install --find-links $BUILD_BINARIESDIRECTORY/whl $PYTHON_PACKAGE_NAME
ln -s /data/models $BUILD_BINARIESDIRECTORY
cd $BUILD_BINARIESDIRECTORY/$BUILD_CONFIG
# Restore file permissions
xargs -a $BUILD_BINARIESDIRECTORY/$BUILD_CONFIG/perms.txt chmod a+x
python3 $BUILD_SOURCESDIRECTORY/tools/ci_build/build.py $BUILD_ARGS --ctest_path ''


text:
package com.socks.zlistview;

import android.app.Activity;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.socks.zlistview.adapter.BaseSwipeAdapter;
import com.socks.zlistview.enums.DragEdge;
import com.socks.zlistview.enums.ShowMode;
import com.socks.zlistview.listener.SimpleSwipeListener;
import com.socks.zlistview.widget.ZSwipeItem;

public class ListViewAdapter extends BaseSwipeAdapter {

	protected static final String TAG = "ListViewAdapter";

	private Activity context;

	public ListViewAdapter(Activity context) {
		this.context = context;
	}

	@Override
	public int getCount() {
		return 20;
	}

	@Override
	public Object getItem(int position) {
		return position;
	}

	@Override
	public long getItemId(int position) {
		return position;
	}

	@Override
	public int getSwipeLayoutResourceId(int position) {
		return R.id.swipe_item;
	}

	@Override
	public View generateView(int position, ViewGroup parent) {
		return context.getLayoutInflater().inflate(R.layout.item_listview,
				parent, false);
	}

	@Override
	public void fillValues(final int position, View convertView) {
		final ZSwipeItem swipeItem = (ZSwipeItem) convertView
				.findViewById(R.id.swipe_item);
		LinearLayout ll = (LinearLayout) convertView.findViewById(R.id.ll);

		TextView tv = (TextView) convertView.findViewById(R.id.tv);
		tv.setText(position + "." + " 测试文本测试文本测试文本测试文本测试文本测试文本测试文本测试文本测试文本");

		if (position % 4 == 1) {
			swipeItem.setShowMode(ShowMode.PullOut);
			swipeItem.setDragEdge(DragEdge.Right);
		} else if (position % 4 == 2) {
			swipeItem.setShowMode(ShowMode.LayDown);
			swipeItem.setDragEdge(DragEdge.Right);
		} else if (position % 4 == 3) {
			swipeItem.setShowMode(ShowMode.PullOut);
			swipeItem.setDragEdge(DragEdge.Left);
		} else if (position % 4 == 0) {
			swipeItem.setShowMode(ShowMode.LayDown);
			swipeItem.setDragEdge(DragEdge.Left);
		}

		swipeItem.addSwipeListener(new SimpleSwipeListener() {
			@Override
			public void onOpen(ZSwipeItem layout) {
				Log.d(TAG, "打开:" + position);
			}

			@Override
			public void onClose(ZSwipeItem layout) {
				Log.d(TAG, "关闭:" + position);
			}

			@Override
			public void onStartOpen(ZSwipeItem layout) {
				Log.d(TAG, "准备打开:" + position);
			}

			@Override
			public void onStartClose(ZSwipeItem layout) {
				Log.d(TAG, "准备关闭:" + position);
			}

			@Override
			public void onHandRelease(ZSwipeItem layout, float xvel, float yvel) {
				Log.d(TAG, "手势释放");
			}

			@Override
			public void onUpdate(ZSwipeItem layout, int leftOffset,
					int topOffset) {
				Log.d(TAG, "位置更新");
			}
		});

		ll.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				Toast.makeText(context, "删除:" + position, Toast.LENGTH_SHORT)
						.show();
				swipeItem.close();
			}
		});
	}
}


text:
import { ModelInterface, DictionaryInterface } from "./Typings";

/**
 * Model represents a data model. It provides functionality to set and get field
 * values and internally keep track of changed fields.
 *
 * @export
 * @class Model
 * @implements {ModelInterface}
 */

export class Model implements ModelInterface {

    private data: DictionaryInterface;
    private updates: DictionaryInterface;
    private _isNew: boolean;

    /**
     * Creates an instance of Model.
     * @param {DictionaryInterface} [data]
     *
     * @memberOf Model
     */
    public constructor(data?: DictionaryInterface) {
        var me = this;
        data = data || {};
        me.data = data;
        me.updates = {};
        me._isNew = Object.keys(data).length === 0;
    }

    /**
     * Synchronizes the Model with a new data. This method also act
     * as a reset in an empty dictionary is provided
     *
     * @param {DictionaryInterface} data
     * @returns {this}
     *
     * @memberOf Model
     */
    public sync(data: DictionaryInterface): this {
        var me = this;
        me.data = data;
        me.updates = {};
        me._isNew = false;
        return me;
    }

    /**
     * Returns true is the model is new
     *
     * @returns {boolean}
     *
     * @memberOf Model
     */
    public isNew(): boolean {
        var me = this;
        return me._isNew;
    }

    /**
     * Get the value of the current state of a field, provided that the
     * field exists in the first place, otherwise it will return the
     * default value.
     *
     * @param {string} field
     * @param {*} [defaultValue=null]
     * @returns {*}
     *
     * @memberOf Model
     */
    public getValue(field: string, defaultValue: any = null): any {
        var me = this;
        if (me.updates.hasOwnProperty(field)) {
            return me.updates[field];
        } else if (me.data.hasOwnProperty(field)) {
            return me.data[field];
        } else {
            return defaultValue;
        }
    }

    /**
     * Sets a field value. This function does not checkk whether the fiels is
     * part of the Model
     *
     * @param {string} field
     * @param {*} value
     * @returns {this}
     *
     * @memberOf Model
     */
    public setValue(field: string, value: any): this {
        var me = this;
        me.updates[field] = value;
        return me;
    }

    /**
     * Returns a dictionary with the updated data
     *
     * @returns {DictionaryInterface}
     *
     * @memberOf Model
     */
    public getUpdates(): DictionaryInterface {
        var me = this;
        return me.updates;
    }

    /**
     * Returns a dictionary with the initial data that was provided to the
     * constructor.
     *
     * @returns {DictionaryInterface}
     *
     * @memberOf Model
     */
    public getInitial(): DictionaryInterface {
        var me = this;
        return me.data;
    }

    /**
     * Returns an dictionary with the current state of the Model
     *
     * @returns {DictionaryInterface}
     *
     * @memberOf Model
     */
    public getData(): DictionaryInterface {
        var me = this, r: DictionaryInterface = {};
        return Object.assign({}, me.data, me.updates);
    }

    /**
     * Retuns a JSON string representing the Model
     *
     * @returns
     *
     * @memberOf Model
     */
    public toJsonString() {
        var me = this;
        return JSON.stringify(me.getData());
    }
}


text:
swoole_http_client_coro/websocket: bug use client in server
--SKIPIF--
<?php require __DIR__ . '/../../include/skipif.inc'; ?>
--FILE--
<?php
require __DIR__ . '/../../include/bootstrap.php';
$pm = new SwooleTest\ProcessManager;
$pm->parentFunc = function () use ($pm) {
    go(function () use ($pm) {
        $cli = new Swoole\Coroutine\Http\Client('127.0.0.1', $pm->getFreePort());
        $cli->set(['timeout' => -1]);
        $ret = $cli->upgrade('/');
        Assert::assert($ret);
        echo $cli->recv()->data;
        for ($i = 0; $i < 5; $i++) {
            $cli->push("hello server\n", SWOOLE_WEBSOCKET_OPCODE_TEXT, true);
            echo ($cli->recv(1))->data;
            co::sleep(0.1);
        }
        $cli->close();
    });
    Swoole\Event::wait();
    $pm->kill();
};
$pm->childFunc = function () use ($pm) {
    $ws = new Swoole\WebSocket\Server('127.0.0.1', $pm->getFreePort(), SWOOLE_PROCESS);
    $ws->set([
        'log_file' => '/dev/null',
        'worker_num' => 1
    ]);
    $ws->on('workerStart', function (Swoole\WebSocket\Server  $serv) use ($pm) {
        $pm->wakeup();
    });
    $ws->on('open', function (Swoole\WebSocket\Server  $ws, Swoole\Http\Request $request) {
        $ws->push($request->fd, "server: hello, welcome\n");
    });
    $ws->on('message', function (Swoole\WebSocket\Server  $ws, Swoole\WebSocket\Frame $frame) {
        echo "client: {$frame->data}";
        $frame->data = str_replace('server', 'client', $frame->data);
        $ws->push($frame->fd, "server-reply: {$frame->data}");
    });
    $ws->on('close', function (Swoole\WebSocket\Server  $ws, int $fd) {
        echo "client-{$fd} is closed\n";
    });
    $ws->start();
};
$pm->childFirst();
$pm->run();
?>
--EXPECT--
server: hello, welcome
client: hello server
server-reply: hello client
client: hello server
server-reply: hello client
client: hello server
server-reply: hello client
client: hello server
server-reply: hello client
client: hello server
server-reply: hello client
client-1 is closed


text:
package com.rodbate.rpc.common;

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;

public class SemaphoreReleaseOnlyOnce {

    private final AtomicBoolean releaseOnce = new AtomicBoolean(false);

    private final Semaphore semaphore;

    public SemaphoreReleaseOnlyOnce(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    public void release()
    {
        if (semaphore != null && releaseOnce.compareAndSet(false, true))
        {
            semaphore.release();
        }
    }

    public Semaphore getSemaphore() {
        return semaphore;
    }
}


text:
package com.cognifide.aet.proxy;

import com.cognifide.aet.job.api.exceptions.ProxyException;
import com.cognifide.aet.proxy.configuration.RestProxyManagerConf;
import com.github.detro.browsermobproxyclient.BMPCProxy;
import com.github.detro.browsermobproxyclient.exceptions.BMPCUnableToConnectException;
import com.github.detro.browsermobproxyclient.manager.BMPCDefaultManager;
import com.google.common.collect.Sets;
import java.util.Set;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.metatype.annotations.Designate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(immediate = true)
@Designate(ocd = RestProxyManagerConf.class)
public class RestProxyManager implements ProxyManager {

  public static final String CREATE_PROXY_EXCEPTION_FORMAT = "Unable to create proxy! Reached max attempts: %d";

  private static final String NAME = "rest";

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

  private final Set<RestProxyServer> proxies = Sets.newHashSet();

  private RestProxyManagerConf config;

  private BMPCDefaultManager manager;

  @Override
  public String getName() {
    return NAME;
  }

  @Activate
  public void activate(RestProxyManagerConf config) {
    this.config = config;
  }

  @Deactivate
  public void deactivate() {
    for (RestProxyServer proxy : proxies) {
      proxy.stop();
    }
  }

  @Override
  public RestProxyServer createProxy() throws ProxyException {
    RestProxyServer proxy;
    if (manager == null) {
      manager = new BMPCDefaultManager(config.server(), config.port());
    }
    proxy = new RestProxyServer(getBmpcProxy(), this);
    proxies.add(proxy);
    LOG.info("RestProxyServer created on server: " + getServer() + " ; port: " + proxy.getPort());
    return proxy;
  }

  private BMPCProxy getBmpcProxy() throws ProxyException {
    BMPCProxy bmpcProxy = null;
    int attempt = 0;
    while (bmpcProxy == null) {
      try {
        bmpcProxy = manager.createProxy();
      } catch (BMPCUnableToConnectException e) {
        if (++attempt >= config.maxAttempts()) {
          throw new ProxyException(
              String.format(CREATE_PROXY_EXCEPTION_FORMAT, config.maxAttempts()), e);
        }

        LOG.warn(
            String.format("Failed to create Proxy attempt %d/%d", attempt, config.maxAttempts()));
        try {
          Thread.sleep(config.attemptsInterval());
        } catch (InterruptedException e1) {
          Thread.currentThread().interrupt();
        }

      }
    }
    return bmpcProxy;
  }

  public void detach(RestProxyServer proxy) {
    proxies.remove(proxy);
  }

  public String getServer() {
    return config.server();
  }

  public int getPort() {
    return config.port();
  }

}


text:
package breeze.integrate

import breeze.linalg._
import org.apache.commons.math3.ode.nonstiff.{AdamsMoultonIntegrator => ApacheAdamsMoultonIntegrator}

class AdamsMoultonIntegrator(
	order: Int,
    minStep: Double,
    maxStep: Double,
    relTol: DenseVector[Double] = null,
    absTol: DenseVector[Double] = null)
  extends ApacheAdamsIntegrator(relTol, absTol) {

  type T = ApacheAdamsMoultonIntegrator

  protected final def create: ApacheAdamsMoultonIntegrator =
    new ApacheAdamsMoultonIntegrator(order - 1, minStep, maxStep, ApacheAdaptiveStepIntegrator.defaultAbsTol, ApacheAdaptiveStepIntegrator.defaultRelTol)
}


text:
\documentclass[czech]{ExcelAtFIT}
%\documentclass[czech]{ExcelAtFIT} % when writing in CZECH
%\documentclass[slovak]{ExcelAtFIT} % when writing in SLOVAK
\usepackage{listings}
\definecolor{lightgray}{rgb}{.9,.9,.9}
\definecolor{darkgray}{rgb}{.4,.4,.4}
\definecolor{purple}{rgb}{0.65, 0.12, 0.82}
\lstdefinelanguage{PHP}{
  keywords={instanceof, void, new, true, false, catch, function, return, null, switch, AND, var, if, while, do, for, else, as, elseif, case, break, include, require, foreach, echo},
  keywordstyle=\color{blue}\bfseries,
  ndkeywords={class, extend, implements, array, bool, int, string, float, throw, this},
  ndkeywordstyle=\color{darkgray}\bfseries,
  %identifierstyle=\color{black},
  sensitive=false,
  comment=[l]{//},
  morecomment=[s]{/*}{*/},
  %commentstyle=\color{purple}\ttfamily,
  %stringstyle=\color{red}\ttfamily,
  keywordstyle=\bfseries\color{red!70!black},
  commentstyle=\itshape\color{purple!40!black},
  identifierstyle=\color{blue},
  stringstyle=\color{orange},
  morestring=[b]',
  morestring=[b]"
}

\lstdefinestyle{customPhp}{
  belowcaptionskip=1\baselineskip,
  breaklines=true,
  frame=L,
  xleftmargin=\parindent,
  language=PHP,
  showstringspaces=false,
  basicstyle=\footnotesize\ttfamily,
  keywordstyle=\bfseries\color{green!40!black},
  commentstyle=\itshape\color{purple!40!black},
  identifierstyle=\color{blue},
  stringstyle=\color{orange},
}

\lstset{
   language=PHP,
   backgroundcolor=\color{white},
   extendedchars=true,
   basicstyle=\footnotesize\ttfamily,
   showstringspaces=false,
   showspaces=false,
   numbers=left,
   numberstyle=\footnotesize,
   numbersep=9pt,
   tabsize=2,
   breaklines=true,
   showtabs=false,
   captionpos=b,
   style=customPhp
}

\renewcommand{\lstlistingname}{Kód}
\newcommand{\function}[1]{\texttt{#1}}

\def\UrlBreaks{\do\/\do-}

%--------------------------------------------------------
%--------------------------------------------------------
%	REVIEW vs. FINAL VERSION
%--------------------------------------------------------

%   LEAVE this line commented out for the REVIEW VERSIONS
%   UNCOMMENT this line to get the FINAL VERSION
\ExcelFinalCopy

%--------------------------------------------------------
%--------------------------------------------------------
%	PDF CUSTOMIZATION
%--------------------------------------------------------

\hypersetup{
	pdftitle={Překlad podmnožiny jazyka PHP do C++},
	pdfauthor={Stanislav Nechutný},
	pdfkeywords={PHP, C++, Translation, Module}
}

%--------------------------------------------------------
%--------------------------------------------------------
%	ARTICLE INFORMATION
%--------------------------------------------------------

\ExcelYear{2016}

\PaperTitle{Překlad podmnožiny jazyka PHP do C++}

\Authors{Stanislav Nechutný*}
\affiliation{*
  \href{mailto:xnechu01@stud.fit.vutbr.cz}{xnechu01@stud.fit.vutbr.cz},
  \textit{Faculty of Information Technology, Brno University of Technology}}

\Keywords{PHP --- C++ --- Překlad --- Rozšíření}

\Supplementary{\href{https://www.github.com/nechutny/BP}{Zdrojový kód}}

%--------------------------------------------------------
%--------------------------------------------------------
%	ABSTRACT and TEASER
%--------------------------------------------------------

\Abstract{

Tato práce se zaměřuje na návrh a tvorbu nástroje pro automatizovaný překlad funkcí napsaných v~podmnožině jazyka PHP do C++. Vygenerovaný zdrojový kód je možno zkompilovat jako rozšíření PHP a zavést stejným způsobem jako například MySQL, PDO, GD apod. Ve výsledku je tedy možno zavolat tyto funkce z~PHP, jako by se jednalo o~původní interpretovanou funkci. Předpokladem je však rozdíl v~rychlosti vykonávání, protože odpadá analýza zdrojových kódů, jejich interpretace, či režie způsobená správou paměti. Vytvořený nástroj provádí převod zdrojového kódu do abstraktního syntaktického stromu, staticky jej analyzuje pro určení datových typů proměnných, a následně provádí generování C++ kódu. Výsledné zrychlení pak záleží na charakteristice překládaného kódu a použití je komplikované kvůli implementaci podmnožiny PHP.
%This papper focus on development of tool for automated translation functions written in PHP 5.6 language into C++ source. Targeted output source code should be compiled as PHP extension module and loaded in the same way as MySQL PDO, GD etc. So in result we can call these functions from PHP as originals, but is expected faster execution, because we don't need more to parse and interpret source plus garbage collector is no more needed. Developed tool parse input source into abstract syntactic tree and analyze them for determining variable types and generate output code.
}

%\Teaser{
%	\TeaserImage{placeholder.pdf}
%	\TeaserImage{placeholder.pdf}
%	\TeaserImage{placeholder.pdf}
%}

%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
\begin{document}

\startdocument

%--------------------------------------------------------
%--------------------------------------------------------
%	ARTICLE CONTENTS
%--------------------------------------------------------

%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
\section{Úvod}

	%\textbf{[Motivation (9 lines)]}
		%\phony{What is the raison d'\^{e}tre of your project? Why should anyone care? No general meaningless claims. Make bulletproof arguments for the importance of your work.}

		Současné webové aplikace napsané v~PHP obsahují desítky knihoven, které programátoři nepotřebují upravovat a chtějí je jen použít. Tyto knihovny někdy provádějí výpočetně náročné operace a jelikož jsou interpretovány, tak dochází k~zpomalení v~důsledku použitých mechanismů. Příkladem je správa paměti, která může způsobovat výrazné zpomalení. Na tuto skutečnost poukázala optimalizace nástroje Composer, které bylo dosaženo vypnutím automatického u\-vol\-ňo\-vá\-ní nepoužívané paměti, a dosáhla 30\% - 90\% zrych\-lení (v~závislosti na množství prováděných operací)\cite{gcOptimize}. Dlouhá doba načítání webové stránky je jedním z~hlav\-ních důvodů pro opuštění návštěvníkem. Škálování takových náročných systémů pak nemusí být e\-ko\-no\-mic\-ké řešení. Tento nástroj však umožňuje snížit vytížení serverů s~nutností minimální úpravy aplikace.

		%Current web applications written in PHP contains tens of libraries, which programmer doesn't need to modify and just use them. These libraries sometime consume a lot of processor time, because are interpreted and are used other mechanisms from scripting language eg. garbage collector\cite{gcOptimize}. Web application response time is for costumer one of main reason to leave it, and scaling such systems is not economic solution. This solution allow to decrease servers load with minimal need of application modification.

	%\textbf{[Problem definition (17 lines)]}
		 %\phony{What exactly are you solving? What is the core and what is a bonus? What parameters should a proper solution of the problem have? Define the problem precisely and state how its solution should be evaluated.}

		Překlad zdrojového kódu z~dynamicky typovaného jazyka do silně typovaného je problematický hned z~několika důvodů. Prvním je detekce datových typů ze zdrojového kódu. Dále tu máme různé obtížně přeložitelné konstrukce, jako například potlačení chybového výpisu, nebo operátor porovnání.

		%Translating source code from dynamicly typed scripting language to strongly typed compiled code is problematic in a lof of ways. One of the main problems is detecting variable types from source code. Next we have a lot of not so easily translatable constructions such as warning supression, space ship operator etc.

		Překlad probíhá následovně: Nejprve je třeba pro\-vést syntaktickou analázu zdrojových kódů a převést je do abstraktního syntaktického stromu pro následnou analýzu. Na základě této struktury můžeme provést analýzu možných hodnot, graf volání pro detekci datových typů. Toto řešení však nepokrývá veškeré možnosti, takže v~projektu jsem také experimentoval s~generováním kódu pro více variant a následnou volbou vykonaného kódu za běhu na základě obdržených hodnot.

		%Firstly we need to parse existing source and tranform it into abstract syntactic tree for futher analysation. Based on this structure we can analyse varible possible values, call graphs etc. to determine data types. This solution doesn't cover all possibilities, so in this project we are also experimenting with generating code for more types and choosing execution tree at run-time.

		%Poslední část tohoto článku se zabývá porovnáním výkonu přeloženého kódu s~originálním kódem v~PHP \todo{Stihnu?} a problémy s~některými konstrukcemi.

		%Last part of this article focus on benchmark tests of translated code and problems with some constructions.

	%\textbf{[Existing solutions (23 lines)]}
		%\phony{Discuss existing solutions, be fair in identifying their strengths and weaknesses. Cite important works from the field of your topic. Try to define well what is the \textit{state of the art}. You can include a Section 2 titled ``Background'' or ``Previous Works'' and have the details there and make this paragraph short. Or, you can enlarge this paragraph to a whole page. In many scientific papers, \emph{this} is the most valuable part if it is written properly.}

		V~současné době zde není přímo konkurenční ře\-še\-ní. Můžeme porovnat tento projekt s~HPHPc od společnosti Facebook, které však bylo zamýšleno pro kompilaci celé PHP aplikace do jednoho velkého bi\-nár\-ní\-ho sou\-bo\-ru. Toto je rozdílný koncept, jelikož HPHPc vy\-ža\-do\-va\-lo překompilování celé aplikace i v~případě drobné změny a následnou distribuci až několik GB velkého souboru na servery. Představené řešení je však zaměřeno pouze na kompilaci knihoven, které nejsou měněny často a hlavní aplikace je stále interpretována. Projekt HPHPc byl nahrazen projektem HHVM\footnote{\url{http://hhvm.com/}}, který je JIT kompilátor (překládající jen použité části kódu) spouštějící bytecode ve virtálním stroji, čímž řeší zmíněné nedostatky HPHPc\cite{hphpcHipHop}.

		%In current time there isn't direct competitive solution. We can compare this project with Facebook's project HPHPc which intended to compile whole PHP application into one binary executable. This is different concept, because HPHPc's implementation require recompiling application even when was changed only few lines of file and then redistribute eventualy a few gigabites large binary files. This solution is intended to compile just libraries, when they are not changed so often and main application using these libraries is still interpreted. HPHPc project was replaced with HHVM that is Just In Time compiler runing in Virtual Machine which solve problems with recompiling.
		Dále existuje projekt PHC\footnote{\url{http://www.phpcompiler.org/}}, který také kompiluje PHP aplikaci do spustitelného binárního souboru a má experimentální podporu pro generování rozšíření PHP. Bohužel projekt není již přes 6 let udržován a nepodařilo se mi tuto funkcionalitu otestovat. Pro\-blé\-mem byla kompilace programu, která nebyla možná ani na Debian stable s~PHP 5.3 a to i přes různé úpravy kódu a instalaci starších verzí knihoven. Ani pokus kontaktovat dva vývojáře z tohoto projektu pro konzultaci mého řešení se bohužel nezdařil.

		%There is also project PHC that compile too php application into executable binary, but have experimental support for creating php extensions from php code. This feauture can't be tested, because code is no more maintained and I was unable to compile it even not on debian stable with PHP 5.3 and some code changes.

		Většina zbylých řešení ve výsledku pouze zabalí PHP skript do datové části spustitelného souboru a přibalí PHP interpret. Nejedná se tedy de facto o~pře\-kla\-dač, ale o~pouhé zabalení skriptu k~interpretru.

		%Most of other solutions in fact just pack php script into data part of executable containing PHP and interpret it when executed.

	%\textbf{[Our solution (13 lines)]}
		%\phony{Make a quick outline of your approach -- pitch your solution.  The solution will be described in detail later, but give the reader a very quick overview now.}

		Zde zmiňované řešení používá funkce z~PHP pro převod zdrojového kódu na tokeny a přidává další vrstvu abstrakce pro přesnější rozlišení tokenů. Pro parsování zdrojových kódů je použit vlastní parser s~rekurzivním sestupem a zásobníková precedenční analýza. Vlastní řešení bylo zvoleno pro snadnost úpravy, získání veškerých potřebných údajů v~po\-ža\-do\-va\-ném formátu a vyzkoušení si teorie v~praxi.

		%This solution use PHP's functions for tokenizing source code and have added abstract layer for more precise token detection, own recursive parser, stack precedence analysator. Own solution was chosen because of optimizating gather informations.

		Abstraktní syntaktický strom z~precedenční a\-na\-lý\-zy je použit pro zjištění použitých proměnných a operací s~nimi prováděných. Dvěma průchody stromu jsou na základě prováděných operací a volaných funkcí přiřazeny proměnným datové typy. Současně s~par\-so\-vá\-ním a precedenční analýzou probíhá také předávání informací generátorům, které mají na starosti výsledný C++ kód.

		Po úspěšném rozparsování a zanalyzování zdrojového kódu je provedeno generování kódu na základě zjištěných informací,

	%\textbf{[Contributions (7 lines)]}
		%\phony{Sell your solution. Pinpoint your achievements. Be fair and objective.}
		Nástroj, jehož návrh a implemetace je v~tomto článku popisována, je možností, jak dosahnout snadno rychlejší odezvy PHP aplikací. V~současné době je praktické použití komplikované implementací pouhé podmnožiny jazyka PHP a zejména absence objektové části je pro překlad moderních knihoven problematická. To však vzhledem k~pokračujícímu vývoji nemusí být překážkou nastálo.

%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------

\section{PHP}

	Některé knihovny jsou náročné na výpočet a přesto jsou implementovány v~PHP, pro jeho jednoduchost na psaní a velký rozsah funkcí, kdy se není třeba zaměřovat na správu paměti, čtení ze souboru apod. Cílem je ponechat tuto jednoduchost a přinést zrychlení. Pří\-kla\-dem může být rozpoznání obličeje\footnote{\url{https://github.com/mauricesvay/php-facedetection}}, nebo generování PDF z~HTML - mPdf.

	Optimalizace přepisováním částí systému do C/C++ není zcela běžná, ale používá se u~velkých projektů - třeba Yahoo provádí přepisování náročných částí aplikace do C++\cite{yahooCpp}. Z~open source knihoven pak může být příkladem framework Phalcon\footnote{\url{https://phalconphp.com/en/}}, či Ice, které jsou kompletně napsané v~jazyce C. Zpřístupňují MVC model s~databázovou vrstvou, šablonami a dalšími funkcemi, jako klasické frameworky implementované v~PHP. Dle testů\cite{phalconBenchmark} webová aplikace využívající výhod této optimalizace je schopna odbavit násobky pří\-cho\-zích požadavků oproti implementacím v~PHP. Je tedy zřejmé, že tato optimalizace má smysl a právě cílem této práce je zjednodušit tvorbu C++ knihoven pro PHP.

	Životní cyklus PHP rozšíření sestává z~několika stavů.\cite{phpExtensionLife} Při startu PHP jsou načteny sdílené knihovny definované v~konfiguračním souboru direktivou \function{ex\-ten\-sion=} a zavolána funkce vracející informace o~rozšíření. Tyto informace obsahují verzi PHP API, callbacky a funkce, třídy, rozhraní a konstanty, které rozšíření poskytuje.\cite{phpExtensionStructure}

	Po inicializaci PHP jsou zavolány inicializační funkce rozšíření, které umožňují provést alokaci paměti, otevření deskriptorů k~souborům apod. V~tomto kroku je například vhodné, aby rozšíření pro logování otevřelo soubor, do kterého bude zapisovat, jelikož bude pro všechny požadavky stejný a je zbytečné jej otevírat a zavírat při každém požadavku.

	PHP proces čeká na pří\-cho\-zí požadavek k~odbavení. Při jeho přijetí nastaví potřebné proměnné a spustí interpretaci skriptu. Spolu s~nastavením proměnných je zavolán další callback z~rozšíření, který může připravit k~načtení již konkrétní hodnoty pro daný požadavek - může tím být například vlastní implementace session.

	\begin{figure}[t]
		\centering
		\includegraphics[width=1.0\linewidth]{PhpExtensionLifeCycleDiagram.pdf}
		\caption{Životní cyklus PHP rozšíření.}
		\label{fig:phpExtensionLifeCycle}
	\end{figure}

	Následně dochází k~případným voláním funkcí při vykonávání skriptu obsluhujícího požadavek. Po dokončení požadavku je zavolán další callback, který umožňuje provést uvolnění paměti a další operace pro funkcionalitu rozšíření. Z~důvodu optimalizace nedochází po obsloužení požadavku k~ukončení procesu PHP, ale proces čeká na další příchozí požadavek. Pokud dojde k~vypnutí webového serveru, tak je zavolán další callback, který by měl provést úklid zbylých zdrojů - protiklad k~prvně volanému callbacku. Celý tento proces znázorňuje diagram na obrázku č. \ref{fig:phpExtensionLifeCycle}.

	Z~PHP rozšíření není možné ovlivňovat seznam vložených souborů pro funkce \function{include\_once} a \function{re\-qui\-re\_on\-ce}. Pokud bude přeložen zdrojový kód vkládající část pomocí jedné z~těchto funkcí, tak v~době vykonávání bude možné provést opět jedno vložení souboru, který byl vložen v~přeloženém kódu.

	Velmi problematickým je pak překlad konstrukcí jako \function{\$\$varName}, které v~jazyce PHP zpřístupní pro\-měn\-nou, jejíž název je uložen v~proměnné \function{\$varName}. Vzhledem k~tomu, že hodnota proměnné může být předána jako argument funkce, či načtena ze souboru a nemusí být v~době překladu známa, se jedná o~velmi problematickou konstrukci, která není v~současné implementaci podporována.

\section{Výběr podmnožiny PHP}

	Při návrhu nástroje bylo třeba vybrání vhodné pod\-mno\-žin\-y PHP k~implemetaci. Vzhledem k~rozsahu nebylo možné za omezený čas implementovat podporu kompletní gramatiky jazyka. Vybraná podmnožina by měla umožnit tvorbu funkcí, volání funkcí a řízení toku programu. Tedy implementovat konstrukce pro podmínky, cykly a zaměřit se zejména na podporu výrazů, která je klíčová. Při transformaci výrazů mezi těmito jazyky je třeba řešit odlišnosti v~prioritě a chování některých operátorů.

	V~současné době neimplementovanou, ale v~budoucnu plánovanou funkcionalitou je podpora objektového programování - tj. podpora pro třídy, dědičnost, rozhraní, jmenné prostory, mixins apod.

\begin{lstlisting}[caption=Podporované výrazy PHP, label=code:phpCodeExample, language=PHP]
function hello($name, array $arg = [])
{
  foreach($arg AS $a)
  {
    if(rand() AND 1 ** "15")
    {
      echo "Hello ".$name." -- ".$a;
    }
  }
  return str_replace("a","b",$arg);
}
\end{lstlisting}

	Nástroj provádí jako jednu ze svých funkcí analýzu výrazů a kódu pro detekci datových typů. Použití C++ třídy s~přetíženými operátory povádějící převod hodnoty do požadovaného typu pro veškeré proměnné by mohlo mít nepříznivý dopad na rychlost, a proto, pokud je to možné, jsou použity primitivní datové typy \function{long}, \function{double}, \function{std::string}, \function{boolean} a \function{std::vector} / \function{std::map}.

	Kód \ref{code:phpCodeExample} ukazuje některé podporované konstrukce překladače pro převod z~PHP do jazyka C++, které je možné použít v zdrojovém kódu - možnost definovat výchozí hodnotu argumentů, podpora pro mocninu, vyhodnocování výrazů, či volání ve\-sta\-vě\-ných funkcí.

	%- třeba vybrat správnou podmnožinu jazyka, aby z~ní bylo možné sestavit rozumně velké funkce pro testování. Proto se hlavní část zaměřuje na výrazy, kdy je podporována většina operátorů. Zde je třeba řešit spoustu odlišností PHP a C++.

	%- z~důvodu komplexnosti byla vypuštěna objektová část jazyka PHP.

	% - detekce datových typů je podstatná část z~důvodu optimalizace, jelikož režie C++ třídy s~přetíženými operátory provádějící dynamická přetypování je výrazně vyšší, než použtí nativních datových typů jako je double apod.

\section{Experimenty a implementace}

	Před zahájením návrhu a implemetace jsem provedl několik testů pro změření rozdílů doby vykonávání. Na obrázku č. \ref{fig:bubbleSort} můžeme vidět graf ukazující dobu potřebnou pro seřazení stejného pole o~50 000 ná\-hod\-ných číslech algoritmem Bubble sort. Zdrojové kódy obou variant jsou přiloženy u~zdrojového kódu projektu. Výrazný rozdíl časů - 3.42s a 0.24s v~prospěch pro C++ naznačuje, že je možné dosáhnout výrazné optimalizace. V~tomto případě zrychlení 14.24x. Obdobných výsledků hovořících v~prospěch C++ verze zavedené jako rozšíření dosáhly další experimenty. U\-ve\-du dále například součet všech čísel od 1 do 100 000 000 000, kdy čísla jsou ještě více rozdílná - 73s PHP a 0.35s C++. Tyto testy byly prováděny na počítači s~OS Fedora 21 64bit, Intel i7 4702MQ, ReiserFS na SSD. Překladč GCC 4.9.1 s volbou optimalizace -O3. Měření bylo provedeno 50x a vypočten matematický průměr. Žádná z~naměřených hodnot nevybočovala výrazněji z~prů\-mě\-ru.

	%- experimentování s~syntetickým kódem (napsaným za účelem testování, není z~reálné aplikace). Přepis do C++ ručně, tedy zřejmě nejoptimálnější verze. Implementace Bubble sortu pro 50 000 stejných náhodných položek PHP: 3.42s, C++: 0.24s tj. 14.25x rychlejší. Součet čísel od 0 do N PHP: 73s, C++: 0.35s \todo{zanést do grafu}.

\begin{figure}[t]
	\centering
	\includegraphics[width=1.0\linewidth]{bubbleSort.pdf}
	\caption{Porovnání rychlosti Bubble sortu.}
	\label{fig:bubbleSort}
\end{figure}

	Výsledné rychlení bude velmi záležet na charakteristice překládaného kódu. V~případě, že se bude jednat o~pouhá volání vestavěných či knihovních funkcí, které jsou již zkompilované, tak zrychlení bude ma\-xi\-mál\-ně v~řádu jednotek procent, či dokonce nulové. Mnohem zajímavějších výsledků je však možno dosahnout v~případě funkcí, které provádějí ve větší míře operace s~proměnnými, viz výše uvedený Bubble sort.

	Rozšíření je možné implementovat v~C pro\-střed\-nic\-tvím rozhraní definovaného společností Zend, která stojí za referenčním interpretrem PHP. Dokumentace i s~návody je dostupná na jejím webu. Po průzkumu možností jsem zvolil knihovnu PHP-CPP\footnote{\url{http://www.php-cpp.com/}} od spo\-leč\-nos\-ti Copernica, která umožňuje pohodlnější tvorbu PHP rozšíření přidáním abstrakce a zpřístupněním funkcí z~PHP v~prostředí jazyka C++.

	Tato knihovna implementuje třídu \function{Php::Value}, která slouží pro předávání argumentů z~PHP do funkcí implementovaných v~jazyce C++ a zpět. Pro samotné použití v~generovaném kódu místo nativních typů není vhodná, jelikož její provázání s~PHP interpretem má vysokou režii.

	Pro tvorbu programu byl zvolen jazyk PHP, který poskytuje prostředky pro rychlý vývoj s~možnostmi provádět rychlé změny v~kódu. Dalším důvodem pro PHP je vestavěný tokenizer pro zdrojový jazyk. Ten bylo třeba rozšířit o~podrobnější kategorizaci tokenů, o~což se stará vlastní lexikální analyzátor.

	Pro tvorbu abstraktního syntaktického stromu z~tokenů je použit vlastní parser s~rekurzivním sestupem. V~průběhu parsování jsou již předávány generátorům kódu informace o~konstrukcích, které mají generovat a prováděna derivace výrazů precedenční analýzou.

	Před samotným generováním C++ kódu dochází k~detekci datových typů. Tato detekce je provedena ve dvou krocích. Při prvním průchodu stromem jsou určeny požadované vstupní typy hodnot do uzlů stromu a výsledná hodnota na základě operátorů. Například při operaci dělení je zřejmé, že výsledkem bude typ float, či u~konkatenace řetězec a jeho operandy budou také řetězec (u~jiných typů se provede přetypování). Obdobně jsou pak určeny typy hodnot - čísla, řetězce, či návratové hodnoty vestavěných funkcí.

	Druhým průchodem tímto stromem s~již částečnými informacemi o~typech jsou doplněny zbylé typy v~zá\-vis\-los\-ti na operacích - pokud je prováděno sčítání dvou hodnot typu int, tak výsledkem bude int. V~případě, že je jedna z~nich typu double, tak již výsledek bude také typu double. V~případě přiřazení do proměnné je tento typ uložen k~proměnné s~adresou značící místo použití typu.

	Pokud se nepodaří detekovat s~jistotou typ pro\-měn\-né, tak je raději zvolen benevoletnější, který umožní uložit všechny možné hodnoty - tedy pro číslo raději double, než int. V~případě úplné neznalosti typu je použita instance třídy \function{Php::Value} z~knihovny PHP-CPP, která má větší režii, ale umožňuje práci s~všemi datovými typy\cite{phpCppPerformance}.

	Při generování C++ kódu jsou řešeny rozdíly mezi C++ a PHP. Průchodem bloků kódu jsou získány všech\-ny použité proměnné a definovány na začátku funkce. Důvodem je rozdílný obor platnosti proměnných. Dále je v~instanci třídy reprezentující proměnnou uloženo od jaké části kódu byla proměnná definována a kde byla zrušena konstrukcí \function{unset}, aby došlo k~nahrazení konstrukce \function{isset} za správnou hodnotu.

	Další generátor je specializovaný pro generování výrazů. Při generování řeší konverzi výsledků pod\-vý\-ra\-zů na datový typ potřebný pro další operace pro\-střed\-nic\-tvím funkcí \function{php2cpp::to\_string} a \function{php2\-cpp\-::to\_\-float} implementovaných v~C++. Dalším ú\-ko\-lem je konverze operátorů chybějících v~C++. Pro operátor mocniny je volána funkce \function{pow} z~matematické knihovny a rozdílné priority operátorů jsou řešeny zá\-vor\-ko\-vá\-ním.

	Volání vestavěných, či uživatelem definovaných funkcí je řešeno pomocí metod z~knihovny PHP-CPP pro provázání s~interpretrem.

	%- Použití knihovny PHP-CPP, popsat jak zjednodušuje vývoj (třída PHP::Value) a naopak zas nevhodnost postavit řešení čistě na ní - pomalost práce s~tímto datovým typem.

	%- implemetace parseru

	%- precedenční analýza

	%- detekce datových typů - operace, hodnoty, přiřazení výsledků, návratové hodnoty vestavěných funkcí, \todo{ typy parametrů vestavěných funkcí? }, dvojí průchod stromem, uložení v~struktuře adresované cestou v~kodu

%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
\section{Závěr}
\label{sec:Conclusions}

	%\textbf{[Paper Summary]} \phony{What was the paper about, then? What the reader needs to remember about it?}

	Konverze PHP knihoven do C++ je možná a použití dává smysl při konverzi knihoven, či jiných neměnných částí. Tento postup je vhodný i při vývoji, kdy testování trvá kratší dobu a je možno měnit kód aplikace.

	%\textbf{[Highlights of Results]} \phony{Exact numbers. Remind the reader that the paper matters.}

	V~případě jednoduššího kódu je výsledný kód vý\-raz\-ně rychlejší, než původní. Pro složitější konstrukce je komplikované určit přesně datové typy a tak nemusí být zrychlení natolik výrazné, aby se vyplatilo s~přihlédnutím k~možnému zavlečení chyby.

	%\textbf{[Paper Contributions]} \phony{What is the original contribution of this work? Two or three thoughts that one should definitely take home.}

	%\textbf{[Future Work]} \phony{ How can other researchers / developers make use of the results of this work?  Do you have further plans with this work? Or anybody else? }

	Jsou dostupné zdrojové kódy\footnote{\url{https://www.github.com/nechutny/BP}} pod open source licencí Apache 2.0 umožňující vyzkoušet si překlad a v~případě úspěchu nasadit, či se zapojit do vývoje.

	V~budoucnu je plánována podpora tříd, propracovanější detekce datových typů (nyní je občas použit double i když by stačil long), omezení zbytečných volání \function{to\_string} a \function{to\_float}. Dále je plánováno ex\-pe\-ri\-men\-to\-vá\-ní s~další detekcí datových typů, kdy slibné výsledky by mohlo poskytnout sledování hodnot pro\-měn\-ných v~interpretované verzi při provozu. Při dos\-ta\-teč\-ně velkém množství vzorků by bylo možné vygenerovat optimalizovanou verzi + obecnou. Při zavolání knihovny by se poté zvolila varianta dle typů argumentů.

%\section*{Acknowledgements}
%I~would like to thank my supervisor X. Y. for his help.

%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
%	REFERENCE LIST
%--------------------------------------------------------
%--------------------------------------------------------
\phantomsection
\bibliographystyle{unsrt}
\bibliography{2016-ExcelFIT-php2cpp-bib}

%--------------------------------------------------------
%--------------------------------------------------------
%--------------------------------------------------------
\end{document}


text:
package com.vaguehope.morrigan.util;

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

public class MnLogger {

	static {
		try {
			LogHelper.bridgeJul();
		}
		catch (final Exception e) {
			e.printStackTrace();
		}
	}

	public static MnLogger make (final Class<?> cls) {
		return new MnLogger(cls);
	}

	private final Logger logger;

	public MnLogger (final Class<?> cls) {
		this.logger = LoggerFactory.getLogger(cls);
	}

	public void e (final String msg, final Object... args) {
		if (!this.logger.isErrorEnabled()) return;
		this.logger.error(msg, args);
	}

	public void e (final String msg, final Throwable t) {
		if (!this.logger.isErrorEnabled()) return;
		this.logger.error(msg, t);
	}

	public void w (final String msg, final Object... args) {
		if (!this.logger.isWarnEnabled()) return;
		this.logger.warn(msg, args);
	}

	public void i (final String msg, final Object... args) {
		if (!this.logger.isInfoEnabled()) return;
		this.logger.info(msg, args);
	}

	public void d (final String msg, final Object... args) {
		if (!this.logger.isDebugEnabled()) return;
		this.logger.debug(msg, args);
	}

}


text:
const log = require('better-log').setConfig({ depth: 8 });

module.exports = log;


text:
title:  Estudo adicional
date:  15/07/2022
---

Textos de Ellen G. White: Patriarcas e Profetas, p. 281-290 ("O êxodo"), p. 291-302 ("Do Mar Vermelho ao Sinai"); O Desejado de Todas as Nações, p. 81-89 [114-123] ("A tentação").

"Na antiguidade o Senhor conduziu Seu povo a Refidim e pode decidir levar-nos para lá a fim de testar nossa fidelidade e lealdade para com Ele. Em misericórdia para conosco, Ele nem sempre nos coloca nos lugares mais fáceis, pois, se o fizesse, em nossa autossuficiência nos esqueceríamos de que o Senhor é nosso ajudador em tempos de necessidade" (Ellen G. White, Cristo Triunfante, p. 119).

"Ele anseia Se manifestar a nós, e revelar os suprimentos abundantes ao nosso dispor, e permite que nos venham provas para reconhecermos nossa limitação e aprendermos a recorrer ao Seu auxílio. Ele faz verter da rocha águas refrescantes.

"Enquanto não estivermos face a face com Deus, quando veremos como somos vistos e conheceremos como somos conhecidos, nunca saberemos quantos fardos Ele suportou por nós, e quantos mais teria alegremente suportado se, com fé pura, os houvéssemos levado a Ele" (Ellen G. White, Minha Consagração Hoje, p. 8, 9).

**Perguntas para consideração**

`1. Embora a tentação seja algo individual, existe alguma tentação coletiva, coisas contra as quais nós, como grupo, devemos nos proteger?`

`2. Você já foi levado a "lugares desagradáveis"? Por que eram desagradáveis? Se tivesse de revisar essas experiências no presente, as veria de forma diferente?`

`3. Deus permite que sejamos purificados por provas. Contudo, como entender as provas que parecem não ter valor – por exemplo, uma morte repentina por acidente?`

`4. A oração intercessória nos ajuda a resistir às provações e nos manter fiéis?`

`5. Conhece alguém que, tendo enfrentado provas, se desviou do caminho? O que podemos fazer de forma tangível para ajudar a conduzir essa pessoa de volta a Deus?`

Respostas e atividades da semana: 1.  Para testar a confiança deles. 2. O povo temeu o Senhor e confiou Nele e em Moisés. 3. Deus fazia prodígios e demonstrava cuidar de Israel. Porém, o povo continuava murmurando. 4. "Está o Senhor no meio de nós ou não?". Resposta pessoal. 5. Jesus não colocou Deus à prova. Ele não dialogou com o tentador. Jesus mencionava passagens da Bíblia. 6. Pedro encorajou os que sofriam provas e tribulações. 7. Eram cristãos que estavam espalhados devido às perseguições. Eram a minoria, e muitos viviam distantes de familiares e amigos. 8. A salvação da alma. A vida eterna com Cristo é a esperança que nos mantém firmes. 9. Comente com a classe.

---

#### Comentários de Ellen G. White

O Desejado de Todas as Nações, p. 81-89 [114-123] ("A tentação").

Este Dia Com Deus [MM 1980], 5 de dezembro, p. 346 ("Luz dentre as trevas").


text:
\cleardoublepage
\pagestyle{fancyplain}
\addtolength{\headwidth}{\marginparsep}
\renewcommand{\chaptermark}[1]%
             {\markboth{#1}{}}
\renewcommand{\sectionmark}[1]%
             {\markright{\thesection\ #1}}
\lhead[\fancyplain{}{\bfseries\thepage}]%
      {\fancyplain{}{\bfseries\rightmark}}
\rhead[\fancyplain{}{\bfseries\leftmark}]%
      {\fancyplain{}{\bfseries\thepage}}
\cfoot{}


text:
#include <aws/devicefarm/model/ListDevicesResult.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/core/AmazonWebServiceResult.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/UnreferencedParam.h>

#include <utility>

using namespace Aws::DeviceFarm::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
using namespace Aws;

ListDevicesResult::ListDevicesResult()
{
}

ListDevicesResult::ListDevicesResult(const AmazonWebServiceResult<JsonValue>& result)
{
  *this = result;
}

ListDevicesResult& ListDevicesResult::operator =(const AmazonWebServiceResult<JsonValue>& result)
{
  const JsonValue& jsonValue = result.GetPayload();
  if(jsonValue.ValueExists("devices"))
  {
    Array<JsonValue> devicesJsonList = jsonValue.GetArray("devices");
    for(unsigned devicesIndex = 0; devicesIndex < devicesJsonList.GetLength(); ++devicesIndex)
    {
      m_devices.push_back(devicesJsonList[devicesIndex].AsObject());
    }
  }

  if(jsonValue.ValueExists("nextToken"))
  {
    m_nextToken = jsonValue.GetString("nextToken");

  }

  return *this;
}