text:
/*! \file replace.h
 *  \brief Defines the interface to a family of
 *         templated replace functions.
 */

#pragma once

#include <thrust/detail/config.h>

namespace thrust
{

/*! \addtogroup transformations
 *  \addtogroup replacing
 *  \ingroup transformations
 *  \{
 */

/*! \p replace replaces every element in the range [first, last) equal to \p old_value
 *  with \p new_value. That is: for every iterator \c i, if <tt>*i == old_value</tt>
 *  then it performs the <tt>assignment *i = new_value</tt>.
 *
 *  \param first The beginning of the sequence of interest.
 *  \param last The end of the sequence of interest.
 *  \param old_value The value to replace.
 *  \param new_value The new value to replace \p old_value.
 *
 *  \tparam ForwardIterator is a model of Forward Iterator,
 *          and \p ForwardIterator is mutable.
 *  \tparam T is a model of Assignable.html">Assignable,
 *          \p T is a model of EqualityComparable,
 *          objects of \p T may be compared for equality with objects of
 *          \p ForwardIterator's \c value_type,
 *          and \p T is convertible to \p ForwardIterator's \c value_type.
 *
 *  The following code snippet demonstrates how to use \p replace to replace
 *  a value of interest in a \c device_vector with another.
 *
 *  \code
 *  #include <thrust/replace.h>
 *  #include <thrust/device_vector.h>
 *  ...
 *  thrust::device_vector<int> v(4);
 *  v[0] = 1;
 *  v[1] = 2;
 *  v[2] = 3;
 *  v[3] = 1;
 *
 *  thrust::replace(v.begin(), v.end(), 1, 99);
 *
 *  // v[0] == 99, v[3] == 99
 *  \endcode
 *
 *  \see http://www.sgi.com/tech/stl/replace.html
 *  \see \c replace_if
 *  \see \c replace_copy
 *  \see \c replace_copy_if
 */
template<typename ForwardIterator, typename T>
  void replace(ForwardIterator first, ForwardIterator last, const T &old_value,
               const T &new_value);

/*! \p replace_if replaces every element in the range <tt>[first, last)</tt> for which
 *  \p pred returns \c true with \p new_value. That is: for every iterator \c i, if
 *  <tt>pred(*i)</tt> is \c true then it performs the assignment <tt>*i = new_value</tt>.
 *
 *  \param first The beginning of the sequence of interest.
 *  \param last The end of the sequence of interest.
 *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
 *  \param new_value The new value to replace elements which <tt>pred(*i)</tt> evaluates
 *         to \c true.
 *
 *  \tparam ForwardIterator is a model of Forward Iterator,
 *          \p ForwardIterator is mutable,
 *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type.
 *  \tparam Predicate is a model of Predicate.
 *  \tparam T is a model of Assignable,
 *          and \p T is convertible to \p ForwardIterator's \c value_type.
 *
 *  The following code snippet demonstrates how to use \p replace_if to replace
 *  a \c device_vector's negative elements with \c 0.
 *
 *  \code
 *  #include <thrust/replace.h>
 *  #include <thrust/device_vector.h>
 *  ...
 *  struct is_less_than_zero
 *  {
 *    __host__ __device__
 *    bool operator()(int x)
 *    {
 *      return x < 0;
 *    }
 *  };
 *  ...
 *  thrust::device_vector<int> v(4);
 *  v[0] =  1;
 *  v[1] = -3;
 *  v[2] =  2;
 *  v[3] = -1;
 *
 *  is_less_than_zero pred;
 *  thrust::replace_if(v.begin(), v.end(), pred, 0);
 *
 *  // v[1] == 0, v[3] == 0
 *  \endcode
 *
 *  \see http://www.sgi.com/tech/stl/replace_if.html
 *  \see \c replace
 *  \see \c replace_copy
 *  \see \c replace_copy_if
 */
template<typename ForwardIterator, typename Predicate, typename T>
  void replace_if(ForwardIterator first, ForwardIterator last,
                  Predicate pred,
                  const T &new_value);

/*! \p replace_if replaces every element in the range <tt>[first, last)</tt> for which
 *  <tt>pred(*s)</tt> returns \c true with \p new_value. That is: for every iterator
 *  \c i in the range <tt>[first, last)</tt>, and \c s in the range <tt>[stencil, stencil + (last - first))</tt>,
 *  if <tt>pred(*s)</tt> is \c true then it performs the assignment <tt>*i = new_value</tt>.
 *
 *  \param first The beginning of the sequence of interest.
 *  \param last The end of the sequence of interest.
 *  \param stencil The beginning of the stencil sequence.
 *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
 *  \param new_value The new value to replace elements which <tt>pred(*i)</tt> evaluates
 *         to \c true.
 *
 *  \tparam ForwardIterator is a model of Forward Iterator,
 *          and \p ForwardIterator is mutable.
 *  \tparam InputIterator is a model of Input Iterator,
 *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
 *  \tparam Predicate is a model of Predicate.
 *  \tparam T is a model of Assignable,
 *          and \p T is convertible to \p ForwardIterator's \c value_type.
 *
 *  The following code snippet demonstrates how to use \p replace_if to replace
 *  a \c device_vector's element with \c 0 when its corresponding stencil element is less than zero.
 *
 *  \code
 *  #include <thrust/replace.h>
 *  #include <thrust/device_vector.h>
 *  ...
 *  struct is_less_than_zero
 *  {
 *    __host__ __device__
 *    bool operator()(int x)
 *    {
 *      return x < 0;
 *    }
 *  };
 *  ...
 *  thrust::device_vector<int> v(4);
 *  v[0] =  1;
 *  v[1] = -3;
 *  v[2] =  2;
 *  v[3] = -1;
 *
 *  thrust::device_vector<int> s(4);
 *  s[0] = -1;
 *  s[1] =  2;
 *  s[2] = -3;
 *  s[3] =  4;
 *
 *  is_less_than_zero pred;
 *  thrust::replace_if(v.begin(), v.end(), s.begin(), pred, 0);
 *
 *  // v[0] == 0, v[2] == 0
 *  \endcode
 *
 *  \see http://www.sgi.com/tech/stl/replace_if.html
 *  \see \c replace
 *  \see \c replace_copy
 *  \see \c replace_copy_if
 */
template<typename ForwardIterator, typename InputIterator, typename Predicate, typename T>
  void replace_if(ForwardIterator first, ForwardIterator last,
                  InputIterator stencil,
                  Predicate pred,
                  const T &new_value);

/*! \p replace_copy copies elements from the range <tt>[first, last)</tt> to the range
 *  <tt>[result, result + (last-first))</tt>, except that any element equal to \p old_value
 *  is not copied; \p new_value is copied instead.
 *
 *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>, \p replace_copy
 *  performs the assignment <tt>*(result+n) = new_value</tt> if <tt>*(first+n) == old_value</tt>,
 *  and <tt>*(result+n) = *(first+n)</tt> otherwise.
 *
 *  \param first The beginning of the sequence to copy from.
 *  \param last The end of the sequence to copy from.
 *  \param result The beginning of the sequence to copy to.
 *  \param old_value The value to replace.
 *  \param new_value The replacement value for which <tt>*i == old_value</tt> evaluates to \c true.
 *  \return <tt>result + (last-first)</tt>
 *
 *  \tparam InputIterator is a model of Input Iterator.
 *  \tparam OutputIterator is a model of Output Iterator.
 *  \tparam T is a model of Assignable,
 *          \p T is a model of Equality Comparable,
 *          \p T may be compared for equality with \p InputIterator's \c value_type,
 *          and \p T is convertible to \p OutputIterator's \c value_type.
 *
 *  \see http://www.sgi.com/tech/stl/replace_copy.html
 *  \see \c copy
 *  \see \c replace
 *  \see \c replace_if
 *  \see \c replace_copy_if
 */
template<typename InputIterator, typename OutputIterator, typename T>
  OutputIterator replace_copy(InputIterator first, InputIterator last,
                              OutputIterator result, const T &old_value,
                              const T &new_value);

/*! \p replace_copy_if copies elements from the range <tt>[first, last)</tt> to the range
 *  <tt>[result, result + (last-first))</tt>, except that any element for which \p pred
 *  is \c true is not copied; \p new_value is copied instead.
 *
 *  More precisely, for every integer \c n such that 0 <= n < last-first,
 *  \p replace_copy_if performs the assignment <tt>*(result+n) = new_value</tt> if
 *  <tt>pred(*(first+n))</tt>, and <tt>*(result+n) = *(first+n)</tt> otherwise.
 *
 *  \param first The beginning of the sequence to copy from.
 *  \param last The end of the sequence to copy from.
 *  \param result The beginning of the sequence to copy to.
 *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
 *  \param new_value The replacement value to assign <tt>pred(*i)</tt> evaluates to \c true.
 *  \return <tt>result + (last-first)</tt>
 *
 *  \tparam InputIterator is a model of Input Iterator,
 *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
 *  \tparam OutputIterator is a model of Output Iterator.
 *  \tparam Predicate is a model of Predicate.
 *  \tparam T is a model of Assignable,
 *          and \p T is convertible to \p OutputIterator's \c value_type.
 *
 *  \see http://www.sgi.com/tech/stl/replace_copy_if.html
 *  \see \c replace
 *  \see \c replace_if
 *  \see \c replace_copy
 */
template<typename InputIterator, typename OutputIterator, typename Predicate, typename T>
  OutputIterator replace_copy_if(InputIterator first, InputIterator last,
                                 OutputIterator result,
                                 Predicate pred,
                                 const T &new_value);

/*! This version of \p replace_copy_if copies elements from the range <tt>[first, last)</tt> to the range
 *  <tt>[result, result + (last-first))</tt>, except that any element whose corresponding stencil
 *  element causes \p pred to be \c true is not copied; \p new_value is copied instead.
 *
 *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
 *  \p replace_copy_if performs the assignment <tt>*(result+n) = new_value</tt> if
 *  <tt>pred(*(stencil+n))</tt>, and <tt>*(result+n) = *(first+n)</tt> otherwise.
 *
 *  \param first The beginning of the sequence to copy from.
 *  \param last The end of the sequence to copy from.
 *  \param stencil The beginning of the stencil sequence.
 *  \param result The beginning of the sequence to copy to.
 *  \param pred The predicate to test on every value of the range <tt>[stencil, stencil + (last - first))</tt>.
 *  \param new_value The replacement value to assign when <tt>pred(*s)</tt> evaluates to \c true.
 *  \return <tt>result + (last-first)</tt>
 *
 *  \tparam InputIterator1 is a model of Input Iterator.
 *  \tparam InputIterator2 is a model of Input Iterator
 *                         and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
 *  \tparam OutputIterator is a model of Output Iterator.
 *  \tparam Predicate is a model of Predicate.
 *  \tparam T is a model of Assignable,
 *          and \p T is convertible to \p OutputIterator's \c value_type.
 *
 *  \see \c replace_copy
 *  \see \c replace_if
 */
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate, typename T>
  OutputIterator replace_copy_if(InputIterator1 first, InputIterator1 last,
                                 InputIterator2 stencil,
                                 OutputIterator result,
                                 Predicate pred,
                                 const T &new_value);

/*! \} // end replacing
 *  \} // transformations
 */

}; // end thrust

#include <thrust/detail/replace.inl>


text:
require File.dirname(__FILE__) + '/../spec_helper'

describe UsersController, "dashboard" do
  it "should be accessible when signed in" do
    user = User.make!
    sign_in user
    get :dashboard
    response.should be_success
  end
end

describe UsersController, "delete" do
  it "should be possible for the user" do
    user = User.make!
    sign_in user
    without_delay { delete :destroy, :id => user.id }
    response.should be_redirect
    User.find_by_id(user.id).should be_blank
  end

  it "should be impossible for everyone else" do
    user = User.make!
    nogoodnik = User.make!
    sign_in nogoodnik
    delete :destroy, :id => user.id
    User.find_by_id(user.id).should_not be_blank
  end
end

describe UsersController, "search" do
  it "should work while signed out" do
    get :search
    response.should be_success
  end
end

describe UsersController, "spam" do
  let(:spammer) { User.make!(spammer: true) }

  it "should render 403 when the user is a spammer" do
    get :show, id: spammer.id
    response.response_code.should == 403
  end
end

redpajama_set_name: RedPajamaGithub


text:
import scala.actors.Actor

case class Deposit(amount: Double)
case class Withdraw(amount: Double)
case class Balance(amount: Double)

class AccountActor extends Actor {
  val delay = 5000

  private var balance = 0.0
  def act() {
    while (true) {
      receive {
        case Deposit(amount) => {
          Thread.sleep(delay)
          balance += amount;
          sender ! Balance(balance)
        }
        case Withdraw(amount) => { balance -= amount; reply(Balance(balance)) }
      }
    }
  }
}

object Main extends App {
  println("Hit Ctrl+C to exit")

  val account = new AccountActor
  account.start

  val reply = account !? Deposit(1000)
  println("Sent with !?")
  reply match {
    case Balance(bal) => println("Current Balance: " + bal)
  }

  val replyFuture = account !! Deposit(1000)
  println("Sent with !!")
  println(replyFuture())
}


text:
namespace luabind
{
	LUABIND_API class_info get_class_info(argument const& o)
	{
		lua_State* L = o.interpreter();

		o.push(L);
        detail::object_rep* obj = detail::get_instance(L, -1);

        if (!obj)
        {
            class_info result;
            result.name = lua_typename(L, lua_type(L, -1));
            lua_pop(L, 1);
            result.methods = newtable(L);
            result.attributes = newtable(L);
            return result;
        }

        lua_pop(L, 1);

        obj->crep()->get_table(L);
        object table(from_stack(L, -1));
        lua_pop(L, 1);

        class_info result;
        result.name = obj->crep()->name();
        result.methods = newtable(L);
        result.attributes = newtable(L);

        std::size_t index = 1;

        for (iterator i(table), e; i != e; ++i)
        {
            if (type(*i) != LUA_TFUNCTION)
                continue;

            // We have to create a temporary `object` here, otherwise the proxy
            // returned by operator->() will mess up the stack. This is a known
            // problem that probably doesn't show up in real code very often.
            object member(*i);
            member.push(L);
            detail::stack_pop pop(L, 1);

            if (lua_tocfunction(L, -1) == &detail::property_tag)
            {
                result.attributes[index++] = i.key();
            }
            else
            {
                result.methods[i.key()] = *i;
            }
        }

        return result;
	}

    LUABIND_API object get_class_names(lua_State* L)
    {
        detail::class_registry* reg = detail::class_registry::get_registry(L);

        std::map<type_id, detail::class_rep*> const& classes = reg->get_classes();

        object result = newtable(L);
        std::size_t index = 1;

        for (std::map<type_id, detail::class_rep*>::const_iterator iter = classes.begin();
            iter != classes.end(); ++iter)
        {
            result[index++] = iter->second->name();
        }

        return result;
    }

	LUABIND_API void bind_class_info(lua_State* L)
	{
		module(L)
		[
			class_<class_info>("class_info_data")
				.def_readonly("name", &class_info::name)
				.def_readonly("methods", &class_info::methods)
				.def_readonly("attributes", &class_info::attributes),

            def("class_info", &get_class_info),
            def("class_names", &get_class_names)
		];
	}
}


text:
import {FluxAppInterface} from './Common';

export type ActionType<T> = T & {
  id: symbol;
  defer: T
}

export function makeAction<T extends Function>(fluxapp: FluxAppInterface, name: string, fn: T): ActionType<T> {
  const id = Symbol(name);
  const action = function (...args: any[]) {
    fluxapp.dispatch(id, fn.apply(fn, args))
  } as any as T
  action.bind(action)
  const typedAction = action as ActionType<T>

  typedAction.id = id
  typedAction.defer = ((...args: any[]) => { setTimeout(() => action.apply(null, args)) }) as any as T
  return typedAction
}

export module Actions {
  // function to create simple action
  export function Make<T = void>() {
    return function (key: T): T {
      return key
    }
  }
  export function MakeEmpty() {
    return function () {

    }
  }
}


text:
/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.flowable.common.engine.impl.el;

import java.beans.FeatureDescriptor;
import java.util.Iterator;

import org.flowable.common.engine.api.variable.VariableContainer;
import org.flowable.common.engine.impl.identity.Authentication;
import org.flowable.common.engine.impl.javax.el.ELContext;
import org.flowable.common.engine.impl.javax.el.ELResolver;
import org.flowable.variable.api.delegate.VariableScope;
import org.flowable.variable.api.persistence.entity.VariableInstance;

/**
 * @author Joram Barrez
 */
public class VariableContainerELResolver extends ELResolver {

    public static final String VARIABLE_CONTAINER_KEY = "variableContainer";
    public static final String LOGGED_IN_USER_KEY = "authenticatedUserId";

    @Override
    public Object getValue(ELContext context, Object base, Object property) {
        if (base == null) {
            String variable = (String) property; // according to javadoc, can only be a String
            VariableContainer variableContainer = getVariableContainer(context);
            if (LOGGED_IN_USER_KEY.equals(property)) {
                context.setPropertyResolved(true);
                return Authentication.getAuthenticatedUserId();

            } else if (variableContainer.hasVariable(variable)) {
                Object value = null;
                if (context.getContext(EvaluationState.class) == EvaluationState.WRITE) {
                    if (variableContainer instanceof VariableScope) {
                        VariableInstance variableInstance = ((VariableScope) variableContainer).getVariableInstance(variable);
                        if (!variableInstance.isReadOnly()) {
                            // When we are in a write evaluation context we can only access the variable if it is not read only
                            // e.g. this can happen when using multi instance variable aggregation and someone wants to write to
                            // reviews[0].score, reviews is an aggregated variable which is read only
                            value = variableInstance.getValue();
                        }
                    }
                } else {
                    value = variableContainer.getVariable(variable);
                }
                context.setPropertyResolved(true); // if not set, the next elResolver in the CompositeElResolver will be called
                return value;
            } else if (VARIABLE_CONTAINER_KEY.equals(property)) {
                context.setPropertyResolved(true); // if not set, the next elResolver in the CompositeElResolver will be called
                return variableContainer;
            }
        }
        return null;
    }

    @Override
    public boolean isReadOnly(ELContext context, Object base, Object property) {
        if (base == null) {
            String variable = (String) property;
            return !getVariableContainer(context).hasVariable(variable);
        }
        return true;
    }

    @Override
    public void setValue(ELContext context, Object base, Object property, Object value) {
        if (base == null) {
            String variable = (String) property;
            VariableContainer variableContainer = getVariableContainer(context);
            if (variableContainer.hasVariable(variable)) {
                context.setPropertyResolved(true);
                if (variableContainer instanceof VariableScope) {
                    VariableInstance variableInstance = ((VariableScope) variableContainer).getVariableInstance(variable);
                    if (variableInstance == null || !variableInstance.isReadOnly()) {
                        variableContainer.setVariable(variable, value);
                    }
                } else {
                    variableContainer.setVariable(variable, value);
                }
            }
        }
    }

    protected VariableContainer getVariableContainer(ELContext elContext) {
        return (VariableContainer) elContext.getContext(VariableContainer.class);
    }

    @Override
    public Class<?> getCommonPropertyType(ELContext arg0, Object arg1) {
        return Object.class;
    }

    @Override
    public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext arg0, Object arg1) {
        return null;
    }

    @Override
    public Class<?> getType(ELContext arg0, Object arg1, Object arg2) {
        return Object.class;
    }

}