text:
#ifndef ION_BASE_STLALLOC_ALLOCUNORDEREDSET_H_
#define ION_BASE_STLALLOC_ALLOCUNORDEREDSET_H_

#include <unordered_set>

#include "ion/base/allocatable.h"
#include "ion/base/allocationmanager.h"
#include "ion/base/stlalloc/stlallocator.h"

namespace ion {
namespace base {

// This class can be used in place of std::unordered_set to allow an Ion
// Allocator to be used for memory allocation. There is a constructor that
// takes the Allocator to be used as an argument. For example:
//
//   AllocUnorderedSet<int> local_set(allocator);
//
// AllocUnorderedSet also provides a convenience constructor to declare class
// members of a derived Allocatable class. It uses the same Allocator that was
// used for the Allocatable. For example:
//
//   class MyClass : public Allocatable {
//    public:
//     // The set will use the same Allocator as the MyClass instance.
//     MyClass() : member_set_(*this) {}
//     ...
//    private:
//     AllocUnorderedSet<int> member_set_;
//   };

template <typename Value,
          typename Hash = ::std::hash<Value>,
          typename Pred = ::std::equal_to<Value> >
class AllocUnorderedSet
    : public std::unordered_set<Value, Hash, Pred, StlAllocator<Value> > {
 public:
  typedef StlAllocator<Value> AllocType;
  typedef std::unordered_set<Value, Hash, Pred, AllocType> SetType;

  explicit AllocUnorderedSet(const AllocatorPtr& alloc)
      : SetType(kBucketCountHint, Hash(), Pred(),
                AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  explicit AllocUnorderedSet(const Allocatable& owner)
      : SetType(kBucketCountHint, Hash(), Pred(),
                AllocType(owner.GetNonNullAllocator())) {}

  // These constructors can be used to copy from "STL iterables": anything that
  // provides a pair of compatible iterators via begin() and end().
  template <typename ContainerT>
  AllocUnorderedSet(const AllocatorPtr& alloc, const ContainerT& from)
      : SetType(from.begin(), from.end(), kBucketCountHint, Hash(), Pred(),
                AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  template <typename ContainerT>
  AllocUnorderedSet(const Allocatable& owner, const ContainerT& from)
      : SetType(from.begin(), from.end(), kBucketCountHint, Hash(), Pred(),
                AllocType(owner.GetNonNullAllocator())) {}

 private:
  // C++11 leaves the default bucket count (hint) as an implementation-defined
  // value.  For concreteness we specify libstdc++'s value here.
  // (see b/18172453 for what various platforms defaulted to as of 2014Q3)
  enum { kBucketCountHint = 10 };
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_STLALLOC_ALLOCUNORDEREDSET_H_


text:
<?php
defined('C5_EXECUTE') or die("Access Denied.");
class Concrete5_Controller_Dashboard_System_Environment_FileStorageLocations extends DashboardBaseController {

	var $helpers = array('form','concrete/interface','validation/token', 'concrete/file');

	public function view($updated=false) {
		$helper_file = Loader::helper('concrete/file');
		Loader::model('file_storage_location');
		$fsl = FileStorageLocation::getByID(FileStorageLocation::ALTERNATE_ID);
		if (is_object($fsl)) {
			$this->set('fslName', $fsl->getName());
			$this->set('fslDirectory', $fsl->getDirectory());
		}
	}

	public function storage_saved() {
		$this->set('message', t('File storage locations saved.'));
		$this->view();
	}

	public function save(){
		$helper_file = Loader::helper('concrete/file');
		$validation_token = Loader::helper('validation/token');

		if (!$validation_token->validate("file_storage")) {
			$this->set('error', array($validation_token->getErrorMessage()));
			return;
		}

		Config::save('DIR_FILES_UPLOADED', $this->post('DIR_FILES_UPLOADED'));

		if ($this->post('fslName') != '' && $this->post('fslDirectory') != '') {
			Loader::model('file_storage_location');
			$fsl = FileStorageLocation::getByID(FileStorageLocation::ALTERNATE_ID);
			if (!is_object($fsl)) {
				FileStorageLocation::add($this->post('fslName'), $this->post('fslDirectory'), FileStorageLocation::ALTERNATE_ID);
			} else {
				$fsl->update($this->post('fslName'), $this->post('fslDirectory'));
			}
		}

		$this->redirect('/dashboard/system/environment/file_storage_locations','storage_saved');
	}

}

redpajama_set_name: RedPajamaGithub


text:
package com.hazelcast.cache;

import com.hazelcast.cache.impl.CacheEntryViews;
import com.hazelcast.cache.impl.record.CacheObjectRecord;
import com.hazelcast.internal.serialization.SerializationService;
import com.hazelcast.internal.serialization.impl.DefaultSerializationServiceBuilder;
import com.hazelcast.test.HazelcastParallelClassRunner;
import com.hazelcast.test.HazelcastTestSupport;
import com.hazelcast.test.annotation.ParallelJVMTest;
import com.hazelcast.test.annotation.QuickTest;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;

import javax.cache.expiry.EternalExpiryPolicy;
import javax.cache.expiry.ExpiryPolicy;

import static org.junit.Assert.assertEquals;

@RunWith(HazelcastParallelClassRunner.class)
@Category({QuickTest.class, ParallelJVMTest.class})
public class CacheEntryViewsTest extends HazelcastTestSupport {

    private SerializationService serializationService;

    @Before
    public void setup() {
        serializationService = new DefaultSerializationServiceBuilder().build();
    }

    @Test
    public void testPrivateConstructor() {
        HazelcastTestSupport.assertUtilityConstructor(CacheEntryViews.class);
    }

    private void doCacheEntryViewTest(CacheEntryViews.CacheEntryViewType cacheEntryViewType) {
        String key = "testKey";
        String value = "testValue";
        ExpiryPolicy expiryPolicy = new EternalExpiryPolicy();
        CacheObjectRecord record = new CacheObjectRecord(value, System.currentTimeMillis(), 1234L);
        record.setExpiryPolicy(new EternalExpiryPolicy());
        CacheEntryView cacheEntryView =
                CacheEntryViews.createEntryView(serializationService.toData(key),
                        serializationService.toData(value),
                        serializationService.toData(expiryPolicy),
                        record,
                        cacheEntryViewType);

        assertEquals(key, serializationService.toObject(cacheEntryView.getKey()));
        assertEquals(value, serializationService.toObject(cacheEntryView.getValue()));
        assertEquals(record.getHits(), cacheEntryView.getHits());
        assertEquals(record.getExpirationTime(), cacheEntryView.getExpirationTime());
        assertEquals(record.getLastAccessTime(), cacheEntryView.getLastAccessTime());
        assertInstanceOf(EternalExpiryPolicy.class, serializationService.toObject(cacheEntryView.getExpiryPolicy()));
    }

    @Test
    public void testDefaultCacheEntryView() {
        doCacheEntryViewTest(CacheEntryViews.CacheEntryViewType.DEFAULT);
    }

    @Test
    public void testLazyCacheEntryView() {
        doCacheEntryViewTest(CacheEntryViews.CacheEntryViewType.LAZY);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testInvalidCacheEntryView() {
        doCacheEntryViewTest(null);
    }

}


text:
import * as beam from "../src/apache_beam";
import * as assert from "assert";
import { Context } from "../src/apache_beam/coders/coders";
import {
  BytesCoder,
  IterableCoder,
  KVCoder,
  StrUtf8Coder,
  VarIntCoder,
} from "../src/apache_beam/coders/standard_coders";
import {
  BsonObjectCoder,
  GeneralObjectCoder,
} from "../src/apache_beam/coders/js_coders";
import { BufferReader, BufferWriter } from "protobufjs";

describe("JavaScript native coders", function () {
  describe("BSON Object Coder", function () {
    const bsonCoder = new BsonObjectCoder();
    it("encodes and decodes an object properly", function () {
      const inputObject = {
        str: "astring",
        int: 1,
        float: 1.2345,
        obj: { any: "any" },
        null: null,
        bool: true,
        // 'undef': undefined,  // TODO(pabloem): Figure out how to support undefined encoding/decoding.
        bigint: Number.MAX_SAFE_INTEGER + 100,
      };
      const writer = new BufferWriter();

      const encoded = bsonCoder.encode(
        inputObject,
        writer,
        Context.needsDelimiters
      );

      const buffer = writer.finish();
      const reader = new BufferReader(buffer);
      assert.deepEqual(
        bsonCoder.decode(reader, Context.needsDelimiters),
        inputObject
      );
    });
  });

  describe("general object coder", function () {
    const objCoder = new GeneralObjectCoder();
    it("encodes and decodes an object properly", function () {
      const inputObject = {
        str: "astring",
        int: 1,
        float: 1.2345,
        obj: { any: "any" },
        null: null,
        bool: true,
        array: [1, 2, 3],
        // 'undef': undefined,  // TODO(pabloem): Figure out how to support undefined encoding/decoding.
        bigint: Number.MAX_SAFE_INTEGER + 100,
      };
      const writer = new BufferWriter();

      const encoded = objCoder.encode(
        inputObject,
        writer,
        Context.needsDelimiters
      );

      const buffer = writer.finish();
      const reader = new BufferReader(buffer);
      assert.deepEqual(
        objCoder.decode(reader, Context.needsDelimiters),
        inputObject
      );
    });
    it("encodes and decodes a string properly", function () {
      const inputObject = "abcde";
      const writer = new BufferWriter();

      const encoded = objCoder.encode(
        inputObject,
        writer,
        Context.needsDelimiters
      );

      const buffer = writer.finish();
      const reader = new BufferReader(buffer);
      assert.equal(
        objCoder.decode(reader, Context.needsDelimiters),
        inputObject
      );
    });
    it("encodes and decodes an integer properly", function () {
      const inputObject = 12345678;
      const writer = new BufferWriter();

      const encoded = objCoder.encode(
        inputObject,
        writer,
        Context.needsDelimiters
      );

      const buffer = writer.finish();
      const reader = new BufferReader(buffer);
      assert.deepEqual(
        objCoder.decode(reader, Context.needsDelimiters),
        inputObject
      );
    });
    it("encodes and decodes a float properly", function () {
      const inputObject = 0.12345678;
      const writer = new BufferWriter();

      const encoded = objCoder.encode(
        inputObject,
        writer,
        Context.needsDelimiters
      );

      const buffer = writer.finish();
      const reader = new BufferReader(buffer);
      assert.deepEqual(
        objCoder.decode(reader, Context.needsDelimiters),
        inputObject
      );
    });
    it("encodes and decodes a BigInt properly", function () {
      // TODO(pabloem): THIS TEST NEEDS TO BE sKIPPED BECAUSE VERY LARGE INTS ARE BROKEN
      this.skip();
      const inputObject = Number.MAX_SAFE_INTEGER + 123456789;
      const writer = new BufferWriter();

      const encoded = objCoder.encode(
        inputObject,
        writer,
        Context.needsDelimiters
      );

      const buffer = writer.finish();
      const reader = new BufferReader(buffer);
      assert.deepEqual(
        objCoder.decode(reader, Context.needsDelimiters),
        inputObject
      );
    });
    it("encodes and decodes a true boolean properly", function () {
      const inputObject = true;
      const writer = new BufferWriter();

      const encoded = objCoder.encode(
        inputObject,
        writer,
        Context.needsDelimiters
      );

      const buffer = writer.finish();
      const reader = new BufferReader(buffer);
      assert.equal(
        objCoder.decode(reader, Context.needsDelimiters),
        inputObject
      );
    });
    it("encodes and decodes a false boolean properly", function () {
      const inputObject = false;
      const writer = new BufferWriter();

      const encoded = objCoder.encode(
        inputObject,
        writer,
        Context.needsDelimiters
      );

      const buffer = writer.finish();
      const reader = new BufferReader(buffer);
      assert.equal(
        objCoder.decode(reader, Context.needsDelimiters),
        inputObject
      );
    });
  });
});


text:
{% load silhouette_tags silhouette_filters %}
{% spaceless %}
    <form{{ attrs|to_html_attrs }}{% if form.is_multipart and not attrs.enctype %} enctype="multipart/form-data"{% endif %}>
        {% block csrf %}
            {% csrf_token %}
        {% endblock %}

        {% block form %}
            {% block errors %}
                {% form_errors form %}
            {% endblock %}

            {% block fields %}
                {% form_fields form %}
            {% endblock %}

            {% block formsets %}

            {% endblock %}

            {% block controls %}
                {% form_controls form %}
            {% endblock %}

            {% block media %}
                {% form_media form %}
            {% endblock %}
        {% endblock %}
    </form>
{% endspaceless %}


text:
import { routerActions } from 'react-router-redux';

export const PREPARE_TEST = 'PREPARE_TEST';
export const NEXT_TASK = 'NEXT_TASK';

export function prepareTest(options) {
  return {
    type: PREPARE_TEST,
    options
  };
}

export function startLessonTest(lesson) {
  return dispatch => {
    dispatch(prepareTest({
      lessons: [lesson]
    }));
    dispatch(routerActions.push('/test'));
  };
}

export function nextTask(response) {
  return {
    type: NEXT_TASK,
    response
  };
}


text:
<?php

/**
 * yFormControlSet
 *
 * @package yuki
 * @subpackage forms
 * @author olamedia
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 */
class yFormControlSet implements IteratorAggregate{
    protected $_prefix = null;
    protected $_key = null;
    protected $_controls = array();
    /**
     * Type of layout, see templates folder
     * Possible values:
     * fieldset: Groups related controls and shows a border around them. (<fieldset><legend>)
     * list|ul: Unordered list, each control inside
.
     * ol: Ordered list, each control inside
.
     * block: Vertical layout - each control on a new line (inside
).
     * inline: Shows all controls on a same line, if possible (each inside span).
     * table: Not-so-good, but may be useful for variable-length labels.
     * page: Groups controls as page in a multi-page form.
     * @var string
     */
    protected $_layout = 'block';
    protected $_blockContainer = 'ol';
    protected $_requiredTitle = 'required'; // *
    protected $_optionalTitle = 'optional'; // (optional)
    /**
     * Control set label.
     * For fieldset layout it displayed as <legend>
     * For other types it displayed as <h#>
     * @var string
     */
    protected $_label = null;
    /**
     *
     * @param string $name
     * @return yFormControl
     */
    public function getControl($name){
        if (!isset($this->_controls[$name])){
            // FIXME throw exception
            return;
        }
        if (is_array($this->_controls[$name])){
            $info = $this->_controls[$name];
            $class = $info['class'];
            $inputName = isset($info['name'])?$info['name']:$name;
            $control = new $class($inputName);
            $control->setPrefix($this->_prefix);
            $control->setKey($this->_key);
            if (isset($info['label'])){
                $control->setLabelText($info['label']);
            }
            if (isset($info['help'])){
                $control->setHelpText($info['help']);
            }
            if (isset($info['required'])){
                $control->setRequired(!!$info['required']);
            }
            if (isset($info['validator'])){
                $validators = $info['validator'];
                if (is_string($validators)){ // 'myValidator'
                    $control->addValidator(new $validators());
                }elseif (is_array($validators)){ // array(validator1, validator2)
                    foreach ($validators as $k=>$v){
                        if (is_string($k) && is_array($v)){ // array(... 'myValidator' => array(options) ...)
                            $validator = new $k($v);
                        }elseif (is_int($k) && is_string($v)){
                            $validator = new $v(); // array(..., 'myValidator', ...)
                        }else{
                            continue; // skip anything else
                        }
                        $control->addValidator($validator);
                    }
                }
            }
            $this->_controls[$name] = $control;
        }
        return $this->_controls[$name];
    }
    public function processKey(){
        foreach ($this->_controls as $name=>$c){
            $control = $this->getControl($name); // force convert to object
            $control->processKey();
        }
    }
    public function getValues(){
        $a = array();
        foreach ($this->_controls as $name=>$c){
            $a[$name] = strval($this->getControl($name)->getValue());
        }
        return $a;
    }
    public function setLabel($label){
        $this->_label = $label;
        return $this;
    }
    public function getLabel(){
        return $this->_label;
    }
    /**
     * Sets name prefix.
     * @param string $prefix Name prefix
     * @return yFormControl
     */
    public function setPrefix($prefix){
        $this->_prefix = $prefix;
        foreach ($this->_controls as $c){
            if (is_object($c)){
                $c->setPrefix($prefix);
            }
        }
        return $this;
    }
    /**
     * Gets name prefix.
     * @return mixed Name prefix string or null
     */
    public function getPrefix(){
        return $this->_prefix;
    }
    /**
     * Sets input key.
     * @param mixed $key Input key
     * @return yFormControl
     */
    public function setKey($key){
        $this->_key = $key;
        foreach ($this->_controls as $c){
            if (is_object($c)){
                $c->setKey($key);
            }
        }
        return $this;
    }
    /**
     * Gets input key.
     * @return mixed Input key
     */
    public function getKey(){
        return $this->_key;
    }
    public function getKeys(){
        $keys = array();
        foreach ($this->_controls as $name=>$c){
            $control = $this->getControl($name);
            $keys = array_merge($keys, $control->getKeys());
        }
        return array_unique($keys);
    }
    public function process(){
        foreach ($this->getKeys() as $key){
            $this->setKey($key);
            $this->processKey();
        }
    }
    public function getSectionHtml($key = null){
        $tpl = dirname(__FILE__).'/templates/'.$this->_layout.'.php';
        return include $tpl;
    }
    public function getFormHtml($key = null){
        $h = '<form method="POST" action="" enctype="multipart/form-data">';
        $h .= $this->getSectionHtml($key);
        $h .= '</form>';
        return $h;
    }
    public function __toString(){
        return (string) $this->getFormHtml();
    }
    protected $_iterator = null;
    /**
     * @return yFormResultIterator
     */
    public function getCurrentIterator(){
        return $this->_iterator;
    }
    /**
     * @return yFormResultIterator
     */
    public function getIterator(){
        $this->_iterator = new yFormResultIterator($this);
        return $this->_iterator;
    }
}


text:
var Behaviors = Behaviors || {};
Behaviors.Requests = Behaviors.Requests || {};

Behaviors.Requests.Base = {
	properties: {
		baseUrl: {
			type: String,
			notify: true,
			value: function(){
				var prefix = 'https://platform.cod.uno';

				if (location.origin.indexOf('localhost') !== -1) {
					prefix = 'http://localhost:8080';
				}

				if (location.origin.indexOf('coduno-lab') !== -1) {
					prefix = 'https://platform-dot-coduno-lab.appspot.com';
				}
				return prefix;
			}
		}
	}
};


text:
using System.Globalization;
using System.Diagnostics;

namespace System.Reflection.Emit
{
    internal sealed class MethodOnTypeBuilderInstantiation : MethodInfo
    {
        #region Private Static Members
        internal static MethodInfo GetMethod(MethodInfo method, TypeBuilderInstantiation type)
        {
            return new MethodOnTypeBuilderInstantiation(method, type);
        }
        #endregion

        #region Private Data Members
        internal MethodInfo m_method;
        private TypeBuilderInstantiation m_type;
        #endregion

        #region Constructor
        internal MethodOnTypeBuilderInstantiation(MethodInfo method, TypeBuilderInstantiation type)
        {
            Debug.Assert(method is MethodBuilder || method is RuntimeMethodInfo);

            m_method = method;
            m_type = type;
        }
        #endregion

        internal override Type[] GetParameterTypes()
        {
            return m_method.GetParameterTypes();
        }

        #region MemberInfo Overrides
        public override MemberTypes MemberType => m_method.MemberType;
        public override string Name => m_method.Name;
        public override Type? DeclaringType => m_type;
        public override Type? ReflectedType => m_type;
        public override object[] GetCustomAttributes(bool inherit) { return m_method.GetCustomAttributes(inherit); }
        public override object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_method.GetCustomAttributes(attributeType, inherit); }
        public override bool IsDefined(Type attributeType, bool inherit) { return m_method.IsDefined(attributeType, inherit); }
        public override Module Module => m_method.Module;
        #endregion

        #region MethodBase Members
        public override ParameterInfo[] GetParameters() { return m_method.GetParameters(); }
        public override MethodImplAttributes GetMethodImplementationFlags() { return m_method.GetMethodImplementationFlags(); }
        public override RuntimeMethodHandle MethodHandle => m_method.MethodHandle;
        public override MethodAttributes Attributes => m_method.Attributes;
        public override object Invoke(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture)
        {
            throw new NotSupportedException();
        }
        public override CallingConventions CallingConvention => m_method.CallingConvention;
        public override Type[] GetGenericArguments() { return m_method.GetGenericArguments(); }
        public override MethodInfo GetGenericMethodDefinition() { return m_method; }
        public override bool IsGenericMethodDefinition => m_method.IsGenericMethodDefinition;
        public override bool ContainsGenericParameters => m_method.ContainsGenericParameters;
        public override MethodInfo MakeGenericMethod(params Type[] typeArgs)
        {
            if (!IsGenericMethodDefinition)
                throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericMethodDefinition, this));

            return MethodBuilderInstantiation.MakeGenericMethod(this, typeArgs);
        }

        public override bool IsGenericMethod => m_method.IsGenericMethod;

        #endregion

        #region Public Abstract\Virtual Members
        public override Type ReturnType => m_method.ReturnType;
        public override ParameterInfo ReturnParameter => throw new NotSupportedException();
        public override ICustomAttributeProvider ReturnTypeCustomAttributes => throw new NotSupportedException();
        public override MethodInfo GetBaseDefinition() { throw new NotSupportedException(); }
        #endregion
    }

    internal sealed class ConstructorOnTypeBuilderInstantiation : ConstructorInfo
    {
        #region Private Static Members
        internal static ConstructorInfo GetConstructor(ConstructorInfo Constructor, TypeBuilderInstantiation type)
        {
            return new ConstructorOnTypeBuilderInstantiation(Constructor, type);
        }
        #endregion

        #region Private Data Members
        internal ConstructorInfo m_ctor;
        private TypeBuilderInstantiation m_type;
        #endregion

        #region Constructor
        internal ConstructorOnTypeBuilderInstantiation(ConstructorInfo constructor, TypeBuilderInstantiation type)
        {
            Debug.Assert(constructor is ConstructorBuilder || constructor is RuntimeConstructorInfo);

            m_ctor = constructor;
            m_type = type;
        }
        #endregion

        internal override Type[] GetParameterTypes()
        {
            return m_ctor.GetParameterTypes();
        }

        internal override Type GetReturnType()
        {
            return m_type;
        }

        #region MemberInfo Overrides
        public override MemberTypes MemberType => m_ctor.MemberType;
        public override string Name => m_ctor.Name;
        public override Type? DeclaringType => m_type;
        public override Type? ReflectedType => m_type;
        public override object[] GetCustomAttributes(bool inherit) { return m_ctor.GetCustomAttributes(inherit); }
        public override object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_ctor.GetCustomAttributes(attributeType, inherit); }
        public override bool IsDefined(Type attributeType, bool inherit) { return m_ctor.IsDefined(attributeType, inherit); }
        internal int MetadataTokenInternal
        {
            get
            {
                ConstructorBuilder? cb = m_ctor as ConstructorBuilder;

                if (cb != null)
                    return cb.MetadataTokenInternal;
                else
                {
                    Debug.Assert(m_ctor is RuntimeConstructorInfo);
                    return m_ctor.MetadataToken;
                }
            }
        }
        public override Module Module => m_ctor.Module;
        #endregion

        #region MethodBase Members
        public override ParameterInfo[] GetParameters() { return m_ctor.GetParameters(); }
        public override MethodImplAttributes GetMethodImplementationFlags() { return m_ctor.GetMethodImplementationFlags(); }
        public override RuntimeMethodHandle MethodHandle => m_ctor.MethodHandle;
        public override MethodAttributes Attributes => m_ctor.Attributes;
        public override object Invoke(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture)
        {
            throw new NotSupportedException();
        }
        public override CallingConventions CallingConvention => m_ctor.CallingConvention;
        public override Type[] GetGenericArguments() { return m_ctor.GetGenericArguments(); }
        public override bool IsGenericMethodDefinition => false;
        public override bool ContainsGenericParameters => false;

        public override bool IsGenericMethod => false;
        #endregion

        #region ConstructorInfo Members
        public override object Invoke(BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture)
        {
            throw new InvalidOperationException();
        }
        #endregion
    }

    internal sealed class FieldOnTypeBuilderInstantiation : FieldInfo
    {
        #region Private Static Members
        internal static FieldInfo GetField(FieldInfo Field, TypeBuilderInstantiation type)
        {
            FieldInfo m;

            // This ifdef was introduced when non-generic collections were pulled from
            // silverlight. See code:Dictionary#DictionaryVersusHashtableThreadSafety
            // for information about this change.
            //
            // There is a pre-existing race condition in this code with the side effect
            // that the second thread's value clobbers the first in the hashtable. This is
            // an acceptable race condition since we make no guarantees that this will return the
            // same object.
            //
            // We're not entirely sure if this cache helps any specific scenarios, so
            // long-term, one could investigate whether it's needed. In any case, this
            // method isn't expected to be on any critical paths for performance.
            if (type.m_hashtable.Contains(Field))
            {
                m = (type.m_hashtable[Field] as FieldInfo)!;
            }
            else
            {
                m = new FieldOnTypeBuilderInstantiation(Field, type);
                type.m_hashtable[Field] = m;
            }

            return m;
        }
        #endregion

        #region Private Data Members
        private FieldInfo m_field;
        private TypeBuilderInstantiation m_type;
        #endregion

        #region Constructor
        internal FieldOnTypeBuilderInstantiation(FieldInfo field, TypeBuilderInstantiation type)
        {
            Debug.Assert(field is FieldBuilder || field is RuntimeFieldInfo);

            m_field = field;
            m_type = type;
        }
        #endregion

        internal FieldInfo FieldInfo => m_field;

        #region MemberInfo Overrides
        public override MemberTypes MemberType => System.Reflection.MemberTypes.Field;
        public override string Name => m_field.Name;
        public override Type? DeclaringType => m_type;
        public override Type? ReflectedType => m_type;
        public override object[] GetCustomAttributes(bool inherit) { return m_field.GetCustomAttributes(inherit); }
        public override object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_field.GetCustomAttributes(attributeType, inherit); }
        public override bool IsDefined(Type attributeType, bool inherit) { return m_field.IsDefined(attributeType, inherit); }
        internal int MetadataTokenInternal
        {
            get
            {
                FieldBuilder? fb = m_field as FieldBuilder;

                if (fb != null)
                    return fb.MetadataTokenInternal;
                else
                {
                    Debug.Assert(m_field is RuntimeFieldInfo);
                    return m_field.MetadataToken;
                }
            }
        }
        public override Module Module => m_field.Module;
        #endregion

        #region Public Abstract\Virtual Members
        public override Type[] GetRequiredCustomModifiers() { return m_field.GetRequiredCustomModifiers(); }
        public override Type[] GetOptionalCustomModifiers() { return m_field.GetOptionalCustomModifiers(); }
        public override void SetValueDirect(TypedReference obj, object value)
        {
            throw new NotImplementedException();
        }
        public override object GetValueDirect(TypedReference obj)
        {
            throw new NotImplementedException();
        }
        public override RuntimeFieldHandle FieldHandle => throw new NotImplementedException();
        public override Type FieldType => throw new NotImplementedException();
        public override object GetValue(object? obj) { throw new InvalidOperationException(); }
        public override void SetValue(object? obj, object? value, BindingFlags invokeAttr, Binder? binder, CultureInfo? culture) { throw new InvalidOperationException(); }
        public override FieldAttributes Attributes => m_field.Attributes;
        #endregion
    }
}


text:
import os
import random
from flask import Flask, make_response, request, current_app
from datetime import timedelta
from functools import update_wrapper
from cobe.brain import Brain

app = Flask(__name__)

def crossdomain(origin=None, methods=None, headers=None,
                max_age=21600, attach_to_all=True,
                automatic_options=True):
    if methods is not None:
        methods = ', '.join(sorted(x.upper() for x in methods))
    if headers is not None and not isinstance(headers, basestring):
        headers = ', '.join(x.upper() for x in headers)
    if not isinstance(origin, basestring):
        origin = ', '.join(origin)
    if isinstance(max_age, timedelta):
        max_age = max_age.total_seconds()

    def get_methods():
        if methods is not None:
            return methods

        options_resp = current_app.make_default_options_response()
        return options_resp.headers['allow']

    def decorator(f):
        def wrapped_function(*args, **kwargs):
            if automatic_options and request.method == 'OPTIONS':
                resp = current_app.make_default_options_response()
            else:
                resp = make_response(f(*args, **kwargs))
            if not attach_to_all and request.method != 'OPTIONS':
                return resp

            h = resp.headers
            h['Access-Control-Allow-Origin'] = origin
            h['Access-Control-Allow-Methods'] = get_methods()
            h['Access-Control-Max-Age'] = str(max_age)
            h['Access-Control-Allow-Credentials'] = 'true'
            h['Access-Control-Allow-Headers'] = \
                "Origin, X-Requested-With, Content-Type, Accept, Authorization"
            if headers is not None:
                h['Access-Control-Allow-Headers'] = headers
            return resp

        f.provide_automatic_options = False
        return update_wrapper(wrapped_function, f)
    return decorator

def responderText(textQuery):
	b = Brain("cobe.brain")
	return b.reply(textQuery)

@app.route('/altbot')
@crossdomain(origin='*')
def altbot():
	textQuery = request.args.get('text')
	return responderText(textQuery)


text:
module.exports = function (gulp, plugins) {
  return function () {
    gulp.src("public/stylesheets/sass/*.scss")
        .pipe(plugins.sass({"outputStyle": "expanded"}).on("error", plugins.sass.logError))
        .pipe(gulp.dest("public/stylesheets/css"))
        .pipe(plugins.autoprefixer({
          browsers: ["> 5%"],
          cascade: true
        }))
        .pipe(plugins.concatCss("css/bundle.css"))
        .pipe(gulp.dest("./build"))
        .pipe(plugins.livereload())
  };
};


text:
import { Component, ViewChild } from '@angular/core';
import { MyTax } from './my-tax';
import { Vehicle } from './vehicle';

@Component({
  templateUrl: 'providers-example.component.html',
  providers: [MyTax]
})
export class ProvidersExampleComponent{

	public name: number;

   	constructor(protected _myTax : MyTax) {
  		this.name = this._myTax.getTaxes();
 	}
}


text:
/**
 * @module node-opcua-address-space
 */
import { assert } from "node-opcua-assert";
import { NodeClass } from "node-opcua-data-model";
import { AttributeIds } from "node-opcua-data-model";
import { DataValue, DataValueLike } from "node-opcua-data-value";
import { NodeId } from "node-opcua-nodeid";
import { StatusCodes } from "node-opcua-status-code";
import * as utils from "node-opcua-utils";
import { DataType } from "node-opcua-variant";
import {
    AddObjectOptions,
    InstantiateObjectOptions,
    ISessionContext,
    UAObject,
    UAObjectType,
    UAReference
} from "node-opcua-address-space-base";

import { SessionContext } from "../source/session_context";
import { BaseNodeImpl } from "./base_node_impl";
import { ToStringBuilder, UAObjectType_toString } from "./base_node_private";
import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSupertypeOf";
import * as tools from "./tool_isSupertypeOf";
import {
    assertUnusedChildBrowseName,
    initialize_properties_and_components,
    topMostParentIsObjectTypeOrVariableType
} from "./ua_variable_type_impl";
import { AddressSpacePrivate } from "./address_space_private";

export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
    public readonly nodeClass = NodeClass.ObjectType;
    public readonly isAbstract: boolean;
    /**
     * returns true if the object has some opcua methods
     */
    public get hasMethods(): boolean {
        return this.getMethods().length > 0;
    }
    public get subtypeOf(): NodeId | null {
        return get_subtypeOf.call(this);
    }
    public get subtypeOfObj(): UAObjectType | null {
        return get_subtypeOfObj.call(this) as any as UAObjectType;
    }
    public isSupertypeOf = tools.construct_isSupertypeOf<UAObjectType>(UAObjectTypeImpl);

    constructor(options: any) {
        super(options);
        this.isAbstract = utils.isNullOrUndefined(options.isAbstract) ? false : options.isAbstract;
    }

    public readAttribute(context: ISessionContext, attributeId: AttributeIds): DataValue {
        assert(context instanceof SessionContext);
        const options: DataValueLike = {};
        switch (attributeId) {
            case AttributeIds.IsAbstract:
                options.value = {
                    dataType: DataType.Boolean,
                    value: !!this.isAbstract
                };
                options.statusCode = StatusCodes.Good;
                break;
            default:
                return BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId);
        }
        return new DataValue(options);
    }

    /**
     * instantiate an object of this UAObjectType
     * The instantiation takes care of object type inheritance when constructing inner properties and components.
     * @method instantiate
     * @param options
     * @param options.browseName
     * @param [options.description]
     * @param [options.organizedBy] the parent Folder holding this object
     * @param [options.componentOf] the parent Object holding this object
     * @param [options.notifierOf]
     * @param [options.eventSourceOf]
     * @param [options.optionals = [] name of the optional child to create
     * @param [options.modellingRule]
     * @param [options.encodingOf]
     *
     *
     * Note : HasComponent usage scope
     *
     *    Source          |     Destination
     * -------------------+---------------------------
     *  Object            | Object, Variable,Method
     *  ObjectType        |
     * -------------------+---------------------------
     *  DataVariable      | Variable
     *  DataVariableType  |
     */
    public instantiate(options: InstantiateObjectOptions): UAObject {
        const addressSpace = this.addressSpace as AddressSpacePrivate;
        assert(!this.isAbstract, "cannot instantiate abstract UAObjectType");

        assert(options, "missing option object");
        assert(
            typeof options.browseName === "string" || (options.browseName !== null && typeof options.browseName === "object"),
            "expecting a browse name"
        );

        assert(!Object.prototype.hasOwnProperty.call(options, "propertyOf"), "an Object shall not be a PropertyOf an other object");
        assert(!Object.prototype.hasOwnProperty.call(options, "optional"), "do you mean optionals ?");

        assertUnusedChildBrowseName(addressSpace, options);

        const baseObjectType = addressSpace.findObjectType("BaseObjectType")!;
        assert(baseObjectType, "BaseObjectType must be defined in the address space");

        const references: UAReference[] = [];

        const copyAlsoModellingRules = topMostParentIsObjectTypeOrVariableType(addressSpace, options);

        const opts: AddObjectOptions = {
            browseName: options.browseName,
            componentOf: options.componentOf,
            displayName: options.displayName || "",
            description: options.description || this.description,
            encodingOf: options.encodingOf,
            eventSourceOf: options.eventSourceOf,
            notifierOf: options.notifierOf,
            organizedBy: options.organizedBy,
            references,

            typeDefinition: this.nodeId,

            nodeId: options.nodeId,

            eventNotifier: options.eventNotifier === undefined ? 0 : options.eventNotifier,

            modellingRule: options.modellingRule
        };

        const namespace = options.namespace || this.addressSpace.getOwnNamespace();

        const instance = namespace.addObject(opts);

        initialize_properties_and_components(instance, baseObjectType, this, copyAlsoModellingRules, options.optionals);

        assert(instance.typeDefinition.toString() === this.nodeId.toString());

        instance.install_extra_properties();

        if (this._postInstantiateFunc) {
            this._postInstantiateFunc(instance, this, options);
        }

        return instance;
    }

    public toString(): string {
        const options = new ToStringBuilder();
        UAObjectType_toString.call(this, options);
        return options.toString();
    }
}


text:
class rectangle {

	public:

        rectangle();

		void	draw();
		void	xenoToPoint(float catchX, float catchY);

		ofPoint		pos;
		ofPoint		prevPos;

		float		angle;

		float		catchUpSpeed;		// take this pct of where I want to be, and 1-catchUpSpeed of my pos

};

#endif // RECTANGLE_H


text:
// var vid = document.getElementById("bgvid");
// var pauseButton = document.querySelector("#polina button");
//
/*** function vidFade() {
  vid.classList.add("stopfade");
}

vid.addEventListener('ended', function()
{
// only functional if "loop" is removed
// vid.pause();
// to capture IE10
// vidFade();
});

pauseButton.addEventListener("click", function() {
  vid.classList.toggle("stopfade");
  if (vid.paused) {
    vid.play();
    pauseButton.innerHTML = "Pause";
  } else {
    vid.pause();
    pauseButton.innerHTML = "Paused";
  }
})
***/

/************************************ footer ************************************************/

$(window).scroll(function(){
 var navTop =  $(window).scrollTop();
 $('.model-0').css("top", navTop + 50);
});

var text_slide_cur=0;
function showtext_slide(){
    $('#text_slide'+(text_slide_cur+1)).css({opacity: 0}).animate({opacity: 1.0,left: "50px"}, 1000);
    setTimeout(hidetext_slide, 3000);
};

function hidetext_slide(){
    $('#text_slide'+(text_slide_cur+1)).css({opacity: 1}).animate({opacity: 0,left: "-50px"}, 1000,function(){showtext_slide();});
    text_slide_cur=(text_slide_cur+1)%5;
}
$(document).ready(function() {
    showtext_slide();
})

/************************************ footer ************************************************/
var slideIndex = 0;
carousel();

function carousel() {
    var i;
    var x = document.getElementsByClassName("mySlides");
    for (i = 0; i < x.length; i++) {
      x[i].style.display = "none";
    }
    slideIndex++;
    if (slideIndex > x.length) {slideIndex = 1}
    x[slideIndex-1].style.display = "block";
    setTimeout(carousel, 2000);
}


text:
import threading
import os
import re
import importlib

from .runtime import runtime_info

class FrameCache(object):
    MAX_CACHE_SIZE = 2500

    def __init__(self, profiler):
        self.profiler = profiler
        self.profiler_frame_cache = None

        self.include_profiler_frames = None

        self.profiler_dir = os.path.dirname(os.path.realpath(__file__))

    def start(self):
        self.profiler_frame_cache = dict()

        self.include_profiler_frames = self.profiler.get_option('include_profiler_frames', False)

    def stop(self):
        pass

    def is_profiler_frame(self, filename):
        if filename in self.profiler_frame_cache:
            return self.profiler_frame_cache[filename]

        profiler_frame = False

        if not self.include_profiler_frames:
            if filename.startswith(self.profiler_dir):
                profiler_frame = True

        if len(self.profiler_frame_cache) < self.MAX_CACHE_SIZE:
            self.profiler_frame_cache[filename] = profiler_frame

        return profiler_frame


text:
// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

#if !defined(__CINT__) || defined(__MAKECINT__)
#include <TClonesArray.h>
#include <TBranch.h>
#include <TTree.h>
#include <TEveManager.h>
#include <TEveElement.h>
#include <TEvePointSet.h>
#include <TTree.h>
#include <TBranch.h>

#include <AliCluster3D.h>
#include <AliRunLoader.h>
#include <AliEveEventManager.h>
#else
class TEveElement;
class TEvePointSet;
class TTree;
class TBranch;
#endif

TEvePointSet* hmpid_clusters(TEveElement* cont=0)
{
  const Int_t nCh=7;
  TClonesArray *cl[nCh] = {0,0,0,0,0,0,0};
  const Char_t *name[nCh]={
    "HMPID0",
    "HMPID1",
    "HMPID2",
    "HMPID3",
    "HMPID4",
    "HMPID5",
    "HMPID6"
  };

  TEvePointSet* clusters = new TEvePointSet(10000);
  clusters->SetOwnIds(kTRUE);

  AliEveEventManager::Instance()->AssertGeometry();

  AliRunLoader* rl = AliEveEventManager::AssertRunLoader();
  rl->LoadRecPoints("HMPID");

  TTree *cTree = rl->GetTreeR("HMPID", false);
  if (!cTree) return 0;

  for (Int_t k=0; k<nCh; k++) {
     TBranch *br=cTree->GetBranch(name[k]);
     if (!br) return 0;
     br->SetAddress(&(cl[k]));
  }

  if (!cTree->GetEvent(0)) return 0;

  for (Int_t i=0; i<nCh; i++) {
    TClonesArray *arr=cl[i];
    Int_t ncl=arr->GetEntriesFast();

    while (ncl--) {
      AliCluster3D *c=(AliCluster3D*)arr->UncheckedAt(ncl);
      Float_t g[3]; //global coordinates
      c->GetGlobalXYZ(g);
      clusters->SetNextPoint(g[0], g[1], g[2]);
      AliCluster3D *atp = new AliCluster3D(*c);
      clusters->SetPointId(atp);
    }
  }

  rl->UnloadRecPoints("HMPID");

  if (clusters->Size() == 0 && gEve->GetKeepEmptyCont() == kFALSE) {
    Warning("hmpid_clusters", "No HMPID clusters");
    delete clusters;
    return 0;
  }

  clusters->SetMarkerStyle(2);
  clusters->SetMarkerSize(0.2);
  clusters->SetMarkerColor(4);

  clusters->SetName("HMPID Clusters");

  clusters->SetTitle(Form("N=%d", clusters->Size()));

  const TString viz_tag("REC Clusters HMPID");

  clusters->ApplyVizTag(viz_tag, "Clusters");

  gEve->AddElement(clusters, cont);

  gEve->Redraw3D();

  return clusters;
}


text:
importClass(Packages.org.dspace.app.xmlui.utils.FlowscriptUtils);
importClass(Packages.org.dspace.app.xmlui.utils.ContextUtil);
importClass(Packages.nz.ac.waikato.its.dspace.app.xmlui.aspect.reports.ReportUtils)

/**
 * Simple access method to access the current cocoon object model.
 */
function getObjectModel()
{
    return FlowscriptUtils.getObjectModel(cocoon);
}
/**
 * Return the DSpace context for this request since each HTTP request generates
 * a new context this object should never be stored and instead allways accessed
 * through this method so you are ensured that it is the correct one.
 */
function getDSContext()
{
    return ContextUtil.obtainContext(getObjectModel());
}
/**
 * Send the current page and wait for the flow to be continued. This method will
 * preform two usefull actions: set the flow parameter & add result information.
 *
 * The flow parameter is used by the sitemap to seperate requests comming from a
 * flow script from just normal urls.
 *
 * The result object could potentialy contain a notice message and a list of
 * errors. If either of these are present then they are added to the sitemap's
 * parameters.
 */
function sendPageAndWait(uri,bizData,result)
{
    if (bizData == null)
        bizData = {};
    if (result != null)
    {
        var outcome = result.getOutcome();
        var header = result.getHeader();
        var message = result.getMessage();
        var characters = result.getCharacters();
        if (message != null || characters != null)
        {
            bizData["notice"] = "true";
            bizData["outcome"] = outcome;
            bizData["header"] = header;
            bizData["message"] = message;
            bizData["characters"] = characters;
        }
        var errors = result.getErrorString();
        if (errors != null)
        {
            bizData["errors"] = errors;
        }
    }
// just to remember where we came from.
    bizData["flow"] = "true";
    cocoon.sendPageAndWait(uri,bizData);
}
/**
 * Send the given page and DO NOT wait for the flow to be continued. Execution will
 * proceed as normal. This method will perform two useful actions: set the flow
 * parameter & add result information.
 *
 * The flow parameter is used by the sitemap to separate requests coming from a
 * flow script from just normal urls.
 *
 * The result object could potentially contain a notice message and a list of
 * errors. If either of these are present then they are added to the sitemap's
 * parameters.
 */
function sendPage(uri,bizData,result)
{
    if (bizData == null)
        bizData = {};
    if (result != null)
    {
        var outcome = result.getOutcome();
        var header = result.getHeader();
        var message = result.getMessage();
        var characters = result.getCharacters();
        if (message != null || characters != null)
        {
            bizData["notice"] = "true";
            bizData["outcome"] = outcome;
            bizData["header"] = header;
            bizData["message"] = message;
            bizData["characters"] = characters;
        }
        var errors = result.getErrorString();
        if (errors != null)
        {
            bizData["errors"] = errors;
        }
    }
// just to remember where we came from.
    bizData["flow"] = "true";
    cocoon.sendPage(uri,bizData);
}

/*********************
 * Entry Point flow
 *********************/

/**
 * Start requesting/sending report
 */
function startSendStandardReport()
{
    var reportName = cocoon.parameters.reportName;
    if (reportName != "")
    {
        var result = doSendStandardReport(reportName);
    }
    cocoon.redirectTo(cocoon.request.getContextPath() + "/reports/standard", true);
    getDSContext().complete();
    cocoon.exit();
}

/*********************
 * Reporting flows
 *********************/

function doSendStandardReport(reportName)
{
    var email;
    var startDate;
    var endDate;
    var result;
    do {
        sendPageAndWait("reports/standard/" + reportName + "/settings", {"reportName": reportName, "email": email, "startDate": startDate, "endDate": endDate}, result);

        // reset result
        result = null;
        // respond to button clicks
        if (cocoon.request.get("submit_report")) {
            result = ReportUtils.processSendReport(getDSContext(),cocoon.request);
            // keep looping so we can show success / error message

            // get variables
            email =  cocoon.request.get("email");
            startDate = cocoon.request.get("fromDate");
            endDate = cocoon.request.get("toDate");
        } else if (cocoon.request.get("submit_cancel")) {
            // go back to where we came from
            return null;
        }
    } while (true)
}


text:
package org.springframework.cloud.sleuth.instrument.web;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.beans.factory.annotation.Qualifier;

/**
 * Annotate a client {@link org.springframework.cloud.sleuth.http.HttpRequestParser}.
 *
 * @see Qualifier
 * @since 2.2.2
 */
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Qualifier(HttpClientRequestParser.NAME)
public @interface HttpClientRequestParser {

	/**
	 * Default name for Sleuth HTTP client request parser.
	 */
	String NAME = "sleuthHttpClientRequestParser";

}


text:
process.title = 'bankai'

require('v8-compile-cache')

var ansi = require('ansi-escape-sequences')
var minimist = require('minimist')
var dedent = require('dedent')
var path = require('path')

var USAGE = `
  $ ${clr('bankai', 'bold')} ${clr('<command> [entry]', 'green')} [options]

  Commands:

    build       compile all files to ${clr('dist/', 'green')}
    inspect     inspect the bundle dependencies
    start       start a development server

  Options:

    -d, --debug       output lots of logs
    -h, --help        print usage
    -q, --quiet       don't output any logs
    -v, --version     print version

  Examples:

    Start a development server
    ${clr('$ bankai start index.js', 'cyan')}

    Visualize all dependencies in your project
    ${clr('$ bankai inspect index.js', 'cyan')}

    Compile all files in the project to disk
    ${clr('$ bankai build index.js', 'cyan')}

  For configuration usage, type 'bankai --help config'

  Running into trouble? Feel free to file an issue:
  ${clr('https://github.com/choojs/bankai/issues/new', 'cyan')}

  Do you enjoy using this software? Become a backer:
  ${clr('https://opencollective.com/choo', 'cyan')}
`.replace(/\n$/, '').replace(/^\n/, '')

var NOCOMMAND = `
  Please specify a bankai command:
    ${clr('$ bankai', 'cyan')} ${clr('<command>', 'green')}

  For example:
    ${clr('$ bankai start', 'cyan')} ${clr('index.js', 'green')}

  Run ${clr('bankai --help', 'cyan')} to see all options.
`.replace(/\n$/, '').replace(/^\n/, '')

var CONFIG_USAGE = `

  ${clr('Configuration', 'bold')}

  Bankai is built on top of compilers for scripts, styles and documents.
  Each of them can be configured by adding a field to your project's
  package.json file.

  These three fields are, respectively: ${clr('"browserify"', 'cyan')}, ${clr('"sheetify"', 'cyan')} and
  ${clr('"documentify"', 'cyan')}. Each one should have a configuration object as it's value.

  There is currently one possible configuration field: "transform".

  It can be one of either:

  1. An array of transform names.
       ie:  ${clr('[ "vueify" ]', 'cyan')}
  2. An array of tuples transform name + configuration object.
       ie: ${clr('[[ "vueify", { "sass": { "includePaths": [ "src/assets/css" ] } } ]]', 'cyan')}

  Full example:

  ${clr(`{
    "browserify": {
      "transform": [
        [ "vueify", { "sass": { "includePaths": [ "src/assets/css" ] } } ]
      ]
    },
    "sheetify": {
      "transform": [
        "sheetify-cssnext"
      ]
    },
    "documentify": {
      "transform": [
        [ "posthtmlify", { "use": [ "posthtml-custom-elements" ] } ]
      ]
    }
  }`, 'cyan')}
`.replace(/\n$/, '').replace(/^\n/, '')

var argv = minimist(process.argv.slice(2), {
  alias: {
    help: 'h',
    quiet: 'q',
    version: 'v',
    base: 'b'
  },
  boolean: [
    'help',
    'quiet',
    'version'
  ]
})

;(function main (argv) {
  var cmd = argv._[0]
  var entry = argv._[1]

  if (entry) {
    if (!path.isAbsolute(entry)) entry = path.join(process.cwd(), entry)
  } else {
    entry = process.cwd()
  }

  if (argv.help) {
    if (cmd === 'config') return console.log(CONFIG_USAGE)
    console.log(USAGE)
  } else if (argv.version) {
    console.log(require('./package.json').version)
  } else if (cmd === 'build') {
    var outdir = argv._[2]
    require('./lib/cmd-build')(path.join(entry), outdir, argv)
  } else if (cmd === 'inspect') {
    require('./lib/cmd-inspect')(path.join(entry), argv)
  } else if (cmd === 'start') {
    if (!argv.q) alternateBuffer()
    require('./lib/cmd-start')(path.join(entry), argv)
  } else {
    console.log(NOCOMMAND)
    process.exit(1)
  }
})(argv)

function clr (text, color) {
  return process.stdout.isTTY ? ansi.format(text, color) : text
}

// Switch to an alternate terminal buffer,
// switch back to the main terminal buffer on exit.
function alternateBuffer () {
  var q = Buffer.from('q')
  var esc = Buffer.from([0x1B])

  process.stdout.write('\x1b[?1049h') // Enter alternate buffer.
  process.stdout.write('\x1b[H') // Reset screen to top.
  process.stdout.write('\x1b[?25l') // Hide cursor

  process.on('unhandledRejection', onexit)
  process.on('uncaughtException', onexit)
  process.on('SIGTERM', onexit)
  process.on('SIGINT', onexit)
  process.on('exit', onexit)
  process.stdin.on('data', handleKey)

  function handleKey (buf) {
    if (buf.compare(q) === 0 || buf.compare(esc) === 0) {
      onexit()
    }
  }

  function onexit (statusCode) {
    process.stdout.write('\x1b[?1049l') // Enter to main buffer.
    process.stdout.write('\x1b[?25h') // Restore cursor

    if (statusCode instanceof Error) {
      console.error('A critical error occured, forcing Bankai to abort:\n')
      console.error(clr(statusCode.stack, 'red') + '\n')
      console.error(dedent`
        If you think this might be a bug in Bankai, please consider helping
        improve Bankai's stability by submitting an error to:

        ${'  ' + clr('https://github.com/choojs/bankai/issues/new', 'underline')}

        Please include the steps to reproduce this error, the stack trace
        printed above, your version of Node, and your version of npm. Thanks!
        ${clr('— Team Choo', 'italic')}
      ` + '\n')
      statusCode = 1
    }

    process.exit(statusCode)
  }
}


text:
body {
	font-family: Arial, sans-serif;
	font-size: 12px;
	margin: 0px;
}
label {
	position: relative;
	vertical-align: middle;
	bottom: 1px;
}
a:visited {
	color:inherit;
}
a {
	color: inherit;
}
input[type=text],
input[type=password],
select,
input[type=email] {
	padding-top: 5px;
	padding-left:5px;
	width:200px;
	font-size: 18px;
	line-height: 20px;
	display: block;
}
input[type=checkbox] {
	margin-bottom: 15px;
}
input[type=submit] {
	background-color: rgba(0, 0, 0, 0);
	background-image: linear-gradient(top, rgb(245, 245, 245), rgb(241, 241, 241));
	background-image: -webkit-linear-gradient(top, rgb(245, 245, 245), rgb(241, 241, 241));
	background-image: -moz-linear-gradient(top, rgb(245, 245, 245), rgb(241, 241, 241));
	border-color: rgba(0, 0, 0, 0.0980392);
	border-style: solid;
	border-width: 1px;
	border-radius: 2px;

	color: rgb(68, 68, 68);
	font-size: 11px;
	font-weight: bold;
	height: 29px;
	line-height: 29px;
	min-width: 54px;
	padding-bottom: 0px;
	padding-left: 8px;
	padding-right: 8px;
	padding-top: 0px;
	text-align: center;
}
input[type=submit]:hover {
	-webkit-box-shadow: rgba(0, 0, 0, 0.14902) 0px 1px 0px 0px;
	border-color: rgb(198, 198, 198);
	box-shadow: rgba(0, 0, 0, 0.14902) 0px 1px 0px 0px;
	color: rgb(34, 34, 34);
	cursor: pointer;
}
.error {
	border: solid 1px red;
}
.navBarContainer {
	width: 100%;
	height: 40px;
	background-color: #FFF;
	border-bottom: solid 1px rgb(232,232,232);
	top:0;
	position: fixed;
	z-index: 5;
}
.navBarLogoContainer {
	font-size: 24px;
	font-weight: bold;
	width: 150px;
	line-height: 40px;
	height: 40px;
	text-align: center;
	float: left;
	cursor: pointer;
	-webkit-transition: background-color .3s;
}
.navBarLogoContainer:hover {
	background-color: #F0F0F0;
}
.navBarSearchContainer {
	width:400px;
	height:30px;
	padding: 5px;
	float: left;
}
.navBarSearchResultsContainer {
	width:406px;
	left:155px;
	top:10px;
	position:absolute;
	display: none;
	border-bottom: solid 1px #FFF;
	box-shadow: 0 0px 10px #888;
	-webkit-user-select: none;
	padding-top:30px;
}
.navbarSearchResultsContainerContent {
	background-color:#FFF;
}
.navbarSearchResultsSectionContainer {
	border-top: solid 1px rgb(232, 232, 232);
	padding:5px;
}
.navbarSearchResultsSectionContainer:hover {
	background-color: rgb(232,232,232);
	cursor: pointer;
}
.navBarSearchBar {
	padding-left:5px;
	width:400px;
	font-size: 18px;
	outline: 0;
	border: 0;
	border-bottom:solid 1px rgb(232,232,232);
	position: absolute;
	z-index: 1;
	margin-top:10px;
}
.navBarUserContainer {
	height: 40px;
	float: right;
	font-size: 18px;
	line-height: 40px;
	text-align: right;
	-webkit-user-select: none;
	right:0;
	background-color: #FFF;
	position: absolute;
	z-index: 5;
	border-bottom: solid 1px rgb(232,232,232);
	overflow: hidden;
	max-width: 400px;
}
.navBarUserContainerExpanded {
	height: 130px;
	float: right;
	font-size: 18px;
	line-height: 40px;
	text-align: right;
	-webkit-user-select: none;
	right:0;
	background-color: #FFF;
	position: absolute;
	z-index: 5;
	border-bottom: solid 1px #FFF;
	box-shadow: 0 0 10px #888;
}
.navBarUserName {
	cursor: pointer;
}
.navBarUserName:hover {
	background-color: #F0F0F0;
}
.navBarUserOptionsLinks {
	width:100%;
	height:30px;
	margin-top:10px;
	background-color: #FFF;
	line-height: 30px;
	font-size: 16px;
	cursor: pointer;
	text-align: center;
	-webkit-transition: background-color .3s;
}
.navBarUserOptionsLinks:hover {
	background-color: #F0F0F0;
}
.navBarUserAvatarContainer {
	width: 30px;
	height: 30px;
	position: relative;
	float: right;
	margin: 5px 5px 5px 10px;
}
.sideBarContainer {
	width:150px;
	height: 100%;
	background-color: #FFF;
	border-right:solid 1px rgb(232,232,232);
	float: left;
	position: fixed;
	top:0;
	margin-top:40px;
	z-index: 4;
}
.mainContentContainer {
	left:150px;
	padding: 0px;
    top: 40px;
	position: absolute;
	min-width: 450px;
	overflow: auto;
}
.mainContentContainerContent {
	padding:10px;
	overflow: auto;
}
.sideBarTabContainer {
	width:150px;
	height:40px;
	margin-top:5px;
	background-color: #FFF;
	line-height: 40px;
	font-size: 20px;
	cursor: pointer;
	text-align: center;
	-webkit-transition: background-color .3s;
}
.sideBarTabContainer:hover {
	background-color:#F0F0F0;
}
.selected {
	background-color: #F0F0F0;
}
.sideBarCoursesSubBar {
	width:150px;
	height:30px;
	margin-top:5px;
	background-color: #FFF;
	line-height: 12px;
	font-size: 12px;
	cursor: pointer;
	text-align: center;
	-webkit-transition: background-color .3s;
}
.sideBarCoursesSubBar:hover {
	background-color:#F0F0F0;
}
.noUnderline {
	text-decoration: none;
}

.coursesCourseContainer {
	border-bottom: solid 1px rgb(232,232,232);
	height:50px;
	-webkit-transition: background-color .3s;
	padding-left:5px;
	padding-right:5px;
}
.coursesCourseContainer:hover {
	background-color:#F0F0F0;
	cursor: pointer;
}
.coursesCourseTitle {
	line-height: 30px;
	font-size: 20px;
}
.coursesCourseTeacher {
	line-height: 20px;
}
.infoAdditionalInfo {
	display: none;
}
.infoAdditionalInfoExpanded {
	display: table-row;
}


text:
class CWorldServer;
// FORWARD END

class ZN_API CowServerGameObject_MOTransport
	: public CowServerGameObject
{
public:
	CowServerGameObject_MOTransport(IScene& Scene, CWorldServer& WoWWorld, CowGuid Guid);
	virtual ~CowServerGameObject_MOTransport();

	std::shared_ptr<CWoWPath> GetWoWPath() const { return m_WoWPath; }
	uint32 GetPathID() const;

	virtual void OnValueUpdated(uint16 index) override;

	// IClientCacheGameobjectResponseListener
	void OnTemplate(CowGuid::EntryType_t Entry, const std::shared_ptr<SGameObjectQueryResult>& QueryResult) override;

	// ISceneNode
	void Update(const UpdateEventArgs& e);

public:
	static std::shared_ptr<CowServerGameObject_MOTransport> Create(CWorldServer& WoWWorld, IScene& Scene, CowGuid Guid);
	virtual void Destroy() override;

private:
	std::string m_TransportName;

	std::shared_ptr<CWoWPath> m_WoWPath;
	uint32 m_PathID;
	float m_PathProgress;
};

#endif


text:
yajaxb-maven-plugin
===================

Yeat another JAXB2 Maven Plugin


text:
/*                     __                                               *\
**     ________ ___   / /  ___     Scala API                            **
**    / __/ __// _ | / /  / _ |    (c) 2003-2010, LAMP/EPFL             **
**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
** /____/\___/_/ |_/____/_/ | |                                         **
**                          |/                                          **
\*                                                                      */

package scala.collection
package immutable

import generic._
import mutable.{ArrayBuffer, Builder}

/** A subtrait of `collection.IndexedSeq` which represents indexed sequences
 *  that are guaranteed immutable.
 *  $indexedSeqInfo
 */
trait IndexedSeq[+A] extends Seq[A]
                    with scala.collection.IndexedSeq[A]
                    with GenericTraversableTemplate[A, IndexedSeq]
                    with IndexedSeqLike[A, IndexedSeq[A]] {
  override def companion: GenericCompanion[IndexedSeq] = IndexedSeq
}

/** $factoryInfo
 *  The current default implementation of a $Coll is a `Vector`.
 *  @define coll indexed sequence
 *  @define Coll IndexedSeq
 */
object IndexedSeq extends SeqFactory[IndexedSeq] {
  @serializable
  class Impl[A](buf: ArrayBuffer[A]) extends IndexedSeq[A] {
    def length = buf.length
    def apply(idx: Int) = buf.apply(idx)
  }
  implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, IndexedSeq[A]] = new GenericCanBuildFrom[A]
  def newBuilder[A]: Builder[A, IndexedSeq[A]] = Vector.newBuilder[A]
}


text:
<feed version="0.3" xmlns="http://purl.org/atom/ns#">
<info type="text/html" mode="escaped"></info>
</feed>


text:
from ..macrospec import std_macro, std_environment, std_specials, \
    MacroSpec, EnvironmentSpec, MacroStandardArgsParser, \
    VerbatimArgsParser, LstListingArgsParser

specs = [
    #
    # CATEGORY: latex-base
    #
    ('latex-base', {
        'macros': [

            std_macro('documentclass', True, 1),
            std_macro('usepackage', True, 1),
            std_macro('RequirePackage', True, 1),
            std_macro('selectlanguage', True, 1),
            std_macro('setlength', True, 2),
            std_macro('addlength', True, 2),
            std_macro('setcounter', True, 2),
            std_macro('addcounter', True, 2),
            std_macro('newcommand', "*{[[{"),
            std_macro('renewcommand', "*{[[{"),
            std_macro('providecommand', "*{[[{"),
            std_macro('newenvironment', "*{[[{{"),
            std_macro('renewenvironment', "*{[[{{"),
            std_macro('provideenvironment', "*{[[{{"),

            std_macro('DeclareMathOperator', '*{{'),

            std_macro('hspace', '*{'),
            std_macro('vspace', '*{'),

            MacroSpec('mbox',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),

            # \title, \author, \date
            MacroSpec('title', '{'),
            MacroSpec('author', '{'),
            MacroSpec('date', '{'),

            # (Note: single backslash) end of line with optional no-break ('*') and
            # additional vertical spacing, e.g. \\*[2mm]
            #
            # Special for this command: don't allow an optional spacing argument
            # [2mm] to be separated by spaces from the rest of the macro.  This
            # emulates the behavior in AMS environments, and avoids some errors;
            # e.g. in "\begin{align} A=0 \\ [C,D]=0 \end{align}" the "[C,D]"
            # does not get captured as an optional macro argument.
            MacroSpec('\\',
                      args_parser=MacroStandardArgsParser('*[', optional_arg_no_space=True)),

            std_macro('item', True, 0),

            # \input{someotherfile}
            std_macro('input', False, 1),
            std_macro('include', False, 1),

            std_macro('includegraphics', True, 1),

            std_macro('chapter', '*[{'),
            std_macro('section', '*[{'),
            std_macro('subsection', '*[{'),
            std_macro('subsubsection', '*[{'),
            std_macro('pagagraph', '*[{'),
            std_macro('subparagraph', '*[{'),

            std_macro('bibliography', '{'),

            std_macro('emph', False, 1),
            MacroSpec('textrm',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('textit',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('textbf',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('textmd',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('textsc',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('textsf',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('textsl',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('texttt',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('textup',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            MacroSpec('text',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[False])),
            std_macro('mathrm', False, 1), # only allowed in math mode anyway
            std_macro('mathbb', False, 1), # only allowed in math mode anyway
            std_macro('mathbf', False, 1),
            std_macro('mathit', False, 1),
            std_macro('mathsf', False, 1),
            std_macro('mathtt', False, 1),
            std_macro('mathcal', False, 1),
            std_macro('mathscr', False, 1),
            std_macro('mathfrak', False, 1),

            std_macro('label', False, 1),
            std_macro('ref', False, 1),
            std_macro('autoref', False, 1),
            std_macro('cref', False, 1),
            std_macro('Cref', False, 1),
            std_macro('eqref', False, 1),
            std_macro('url', False, 1),
            std_macro('hypersetup', False, 1),
            std_macro('footnote', True, 1),

            std_macro('keywords', False, 1),

            std_macro('hphantom', True, 1),
            std_macro('vphantom', True, 1),

            std_macro("'", False, 1),
            std_macro("`", False, 1),
            std_macro('"', False, 1),
            std_macro("c", False, 1),
            std_macro("^", False, 1),
            std_macro("~", False, 1),
            std_macro("H", False, 1),
            std_macro("k", False, 1),
            std_macro("=", False, 1),
            std_macro("b", False, 1),
            std_macro(".", False, 1),
            std_macro("d", False, 1),
            std_macro("r", False, 1),
            std_macro("u", False, 1),
            std_macro("v", False, 1),

            MacroSpec('ensuremath',
                      args_parser=MacroStandardArgsParser('{', args_math_mode=[True])),

            std_macro("not", False, 1),

            std_macro("vec", False, 1),
            std_macro("dot", False, 1),
            std_macro("hat", False, 1),
            std_macro("check", False, 1),
            std_macro("breve", False, 1),
            std_macro("acute", False, 1),
            std_macro("grave", False, 1),
            std_macro("tilde", False, 1),
            std_macro("bar", False, 1),
            std_macro("ddot", False, 1),

            std_macro('frac', False, 2),
            std_macro('nicefrac', False, 2),

            std_macro('sqrt', True, 1),

            MacroSpec('overline', '{'),
            MacroSpec('underline', '{'),
            MacroSpec('widehat', '{'),
            MacroSpec('widetilde', '{'),
            MacroSpec('wideparen', '{'),
            MacroSpec('overleftarrow', '{'),
            MacroSpec('overrightarrow', '{'),
            MacroSpec('overleftrightarrow', '{'),
            MacroSpec('underleftarrow', '{'),
            MacroSpec('underrightarrow', '{'),
            MacroSpec('underleftrightarrow', '{'),
            MacroSpec('overbrace', '{'),
            MacroSpec('underbrace', '{'),
            MacroSpec('overgroup', '{'),
            MacroSpec('undergroup', '{'),
            MacroSpec('overbracket', '{'),
            MacroSpec('underbracket', '{'),
            MacroSpec('overlinesegment', '{'),
            MacroSpec('underlinesegment', '{'),
            MacroSpec('overleftharpoon', '{'),
            MacroSpec('overrightharpoon', '{'),

            MacroSpec('xleftarrow', '[{'),
            MacroSpec('xrightarrow', '[{'),

            std_macro('ket', False, 1),
            std_macro('bra', False, 1),
            std_macro('braket', False, 2),
            std_macro('ketbra', False, 2),

            std_macro('texorpdfstring', False, 2),

            # xcolor commands
            MacroSpec('definecolor', '[{{{'),
            MacroSpec('providecolor', '[{{{'),
            MacroSpec('colorlet', '[{[{'),
            MacroSpec('color', '[{'),
            MacroSpec('textcolor', '[{{'),
            MacroSpec('pagecolor', '[{'),
            MacroSpec('nopagecolor', ''),
            MacroSpec('colorbox', '[{{'),
            MacroSpec('fcolorbox', '[{[{{'),
            MacroSpec('boxframe', '{{{'),
            MacroSpec('rowcolors', '*[{{{'),
        ],
        'environments': [
            # NOTE: Starred variants (as in \begin{equation*}) are not specified as
            # for macros with an argspec='*'.  Rather, we need to define a separate
            # spec for the starred variant as the star really is part of the
            # environment name.  If you specify argspec='*', the parser will try to
            # look for an expression of the form '\begin{equation}*'

            std_environment('figure', '['),
            std_environment('figure*', '['),
            std_environment('table', '['),
            std_environment('table*', '['),

            std_environment('abstract', None),

            std_environment('tabular', '{'),
            std_environment('tabular*', '{{'),
            std_environment('tabularx', '{[{'),

            std_environment('array', '[{'),

            std_environment('equation', None, is_math_mode=True),
            std_environment('equation*', None, is_math_mode=True),
            std_environment('eqnarray', None, is_math_mode=True),
            std_environment('eqnarray*', None, is_math_mode=True),

            # AMS environments
            std_environment('align', None, is_math_mode=True),
            std_environment('align*', None, is_math_mode=True),
            std_environment('gather', None, is_math_mode=True),
            std_environment('gather*', None, is_math_mode=True),
            std_environment('flalign', None, is_math_mode=True),
            std_environment('flalign*', None, is_math_mode=True),
            std_environment('multline', None, is_math_mode=True),
            std_environment('multline*', None, is_math_mode=True),
            std_environment('alignat', '{', is_math_mode=True),
            std_environment('alignat*', '{', is_math_mode=True),
            std_environment('split', None, is_math_mode=True),
        ],
        'specials': [
            std_specials('&'),

            # TODO --- for this, we need to parse their argument but don't use
            #          the standard args parser because we need to be able to
            #          accept arguments like "x_\mathrm{initial}"
            #
            #std_specials('^'),
            #std_specials('_'),
        ]}),

    #
    # CATEGORY: nonascii-specials
    #
    ('nonascii-specials', {
        'macros': [],
        'environments': [],
        'specials': [
            std_specials("~"),

            # cf. https://tex.stackexchange.com/a/439652/32188 "fake ligatures":
            std_specials('``'),
            std_specials("''"),
            std_specials("--"),
            std_specials("---"),
            std_specials("!`"),
            std_specials("?`"),
        ]}),

    #
    # CATEGORY: verbatim
    #
    ('verbatim', {
        'macros': [
            MacroSpec('verb',
                      args_parser=VerbatimArgsParser(verbatim_arg_type='verb-macro')),
            ],
        'environments': [
            EnvironmentSpec('verbatim',
                            args_parser=VerbatimArgsParser(verbatim_arg_type='verbatim-environment')),
        ],
        'specials': [
            # optionally users could include the specials "|" like in latex-doc
            # for verbatim |\like \this|...
        ]}),

    ('lstlisting', {
        'macros': [],
        'environments': [
            EnvironmentSpec('lstlisting', args_parser=LstListingArgsParser()),
        ],
        'specials': [
            # optionally users could include the specials "|" like in latex-doc
            # for lstlisting |\like \this|...
        ]}),

    #
    # CATEGORY: theorems
    #
    ('theorems', {
        'macros': [],
        'environments': [
            std_environment('theorem', '['),
            std_environment('proposition', '['),
            std_environment('lemma', '['),
            std_environment('corollary', '['),
            std_environment('definition', '['),
            std_environment('conjecture', '['),
            std_environment('remark', '['),
            #
            std_environment('proof', '['),
            # short names
            std_environment('thm', '['),
            std_environment('prop', '['),
            std_environment('lem', '['),
            std_environment('cor', '['),
            std_environment('conj', '['),
            std_environment('rem', '['),
            std_environment('defn', '['),
        ],
        'specials': [
        ]}),

    #
    # CATEGORY: enumitem
    #
    ('enumitem', {
        'macros': [],
        'environments': [
            std_environment('enumerate', '['),
            std_environment('itemize', '['),
            std_environment('description', '['),
        ],
        'specials': [
        ]}),

    #
    # CATEGORY: natbib
    #
    ('natbib', {
        'macros': [
            std_macro('cite', '*[[{'),
            std_macro('citet', '*[[{'),
            std_macro('citep', '*[[{'),
            std_macro('citealt', '*[[{'),
            std_macro('citealp', '*[[{'),
            std_macro('citeauthor', '*[[{'),
            std_macro('citefullauthor', '[[{'),
            std_macro('citeyear', '[[{'),
            std_macro('citeyearpar', '[[{'),
            std_macro('Citet', '*[[{'),
            std_macro('Citep', '*[[{'),
            std_macro('Citealt', '*[[{'),
            std_macro('Citealp', '*[[{'),
            std_macro('Citeauthor', '*[[{'),

            std_macro('citetext', '{'),
            std_macro('citenum', '{'),

            std_macro('defcitealias', '{{'),
            std_macro('citetalias', '[[{'),
            std_macro('citepalias', '[[{'),
        ],
        'environments': [
        ],
        'specials': [
        ]}),

    #
    # CATEGORY: latex-ethuebung
    #
    ('latex-ethuebung', {
        'macros': [
            # ethuebung
            std_macro('UebungLoesungFont', False, 1),
            std_macro('UebungHinweisFont', False, 1),
            std_macro('UebungExTitleFont', False, 1),
            std_macro('UebungSubExTitleFont', False, 1),
            std_macro('UebungTipsFont', False, 1),
            std_macro('UebungLabel', False, 1),
            std_macro('UebungSubLabel', False, 1),
            std_macro('UebungLabelEnum', False, 1),
            std_macro('UebungLabelEnumSub', False, 1),
            std_macro('UebungSolLabel', False, 1),
            std_macro('UebungHinweisLabel', False, 1),
            std_macro('UebungHinweiseLabel', False, 1),
            std_macro('UebungSolEquationLabel', False, 1),
            std_macro('UebungTipsLabel', False, 1),
            std_macro('UebungTipsEquationLabel', False, 1),
            std_macro('UebungsblattTitleSeries', False, 1),
            std_macro('UebungsblattTitleSolutions', False, 1),
            std_macro('UebungsblattTitleTips', False, 1),
            std_macro('UebungsblattNumber', False, 1),
            std_macro('UebungsblattTitleFont', False, 1),
            std_macro('UebungTitleCenterVSpacing', False, 1),
            std_macro('UebungAttachedSolutionTitleTop', False, 1),
            std_macro('UebungAttachedSolutionTitleFont', False, 1),
            std_macro('UebungAttachedSolutionTitle', False, 1),
            std_macro('UebungTextAttachedSolution', False, 1),
            std_macro('UebungDueByLabel', False, 1),
            std_macro('UebungDueBy', False, 1),
            std_macro('UebungLecture', False, 1),
            std_macro('UebungProf', False, 1),
            std_macro('UebungLecturer', False, 1),
            std_macro('UebungSemester', False, 1),
            std_macro('UebungLogoFile', False, 1),
            std_macro('UebungLanguage', False, 1),
            std_macro('UebungStyle', False, 1),
            #
            std_macro('uebung', '{['),
            std_macro('exercise', '{['),
            std_macro('keywords', False, 1),
            std_macro('subuebung', False, 1),
            std_macro('subexercise', False, 1),
            std_macro('pdfloesung', True, 1),
            std_macro('pdfsolution', True, 1),
            std_macro('exenumfulllabel', False, 1),
            std_macro('hint', False, 1),
            std_macro('hints', False, 1),
            std_macro('hinweis', False, 1),
            std_macro('hinweise', False, 1),
        ],
        'environments': [
        ],
        'specials': [
        ]
    }),
]


text:
<?php

namespace AppBundle\Controller;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Component\Form\FormError;
/**
 * Page controller.
 */
class PageController extends Controller
{
    /**
     * @Route("/", name="homepage")
     * @Method("GET")
     */
    public function indexAction()
    {
        $em = $this->getDoctrine()->getManager();

        $allBills = $em->getRepository('AppBundle:Bill')->findByAdmin(
            $this->getUser()->getId()
        );
        $unpayed = $em->getRepository('AppBundle:Bill')->findUnpayedByAdmin(
            $this->getUser()->getId()
        );
        $lastStep = $em->getRepository('AppBundle:Bill')->findLaststepByAdmin(
            $this->container->getParameter('laststep_deadline'),
            $this->getUser()->getId()
        );
        $offline = $em->getRepository('AppBundle:Bill')->findOfflineByAdmin(
            $this->getUser()->getId()
        );

        $cntAll = count($allBills);
        $cntOff = count($offline);
        $cntLast = count($lastStep);
        $sumAmt = 0;
        $sumDun = 0;

        foreach ($allBills as $bill) {
            $sumDun += $bill->getReceivedDuns();
            $sumAmt += $bill->getAmount();
        }

        return $this->render('page/index.html.twig', [
            'allBills' => $allBills,
            'unpayed' => $unpayed,
            'offline' => $offline,
            'lastStep' => $lastStep,
            'cntAll' => $cntAll,
            'cntOff' => $cntOff,
            'cntLast' => $cntLast,
            'sumAmt' => $sumAmt,
            'sumDun' => $sumDun
        ]);
    }

     /**
     * Route for changing the admin password
     *
     * @Route("/change-password", name="change_password")
     * @Method({"GET", "POST"})
     */
    public function changePasswordAction(Request $request)
    {
        $form = $this->createForm('AppBundle\Form\ChangePasswordType');
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $em = $this->getDoctrine()->getManager();
            $emAdmin = $em->getRepository('AppBundle:Admin')->find(
                $this->getUser()->getId()
            );

            if ($this->get('security.password_encoder')
                ->isPasswordValid($emAdmin, $form->getData()['currentPassword'])) {
                $hash = $this->get('security.password_encoder')
                             ->encodePassword($emAdmin, $form->getData()['newPassword']);

                $emAdmin->setPassword($hash);

                $em->persist($emAdmin);
                $em->flush();

                return $this->redirectToRoute('homepage');
            }

            $form->get('currentPassword')->addError(
                new FormError('Das aktuelle Passwort ist ungültig.')
            );
        }

        return $this->render('page/changePassword.html.twig', array(
            'form' => $form->createView()
        ));
    }

    /**
     * @Route("/test")
     * @Method("GET")
     */
    public function testAction()
    {
        $bs = $this->get('bill_service');
        $due = $bs->getDue();

        foreach ($due as $d) {
            $bs->dun($d);
        }

        return $this->redirectToRoute('homepage');
    }
}


text:
// ReSharper disable UnusedMember.Local
// ReSharper disable UnusedAutoPropertyAccessor.Local
namespace Equ.Test
{
    using System.Collections.Generic;
    using System.Collections.Immutable;
    using System.Linq;

    using Equ;

    using Xunit;

    public class MemberwiseEquatableTest
    {
        [Fact]
        public void Self_equality_is_sane()
        {
            var x = new ValueType("asdf", 42, true, new CustomRefType("qwer"), new ValueType2("xyz"));

#pragma warning disable 1718
            // ReSharper disable EqualExpressionComparison
            Assert.True(x.Equals(x));
            Assert.True(x == x);
            Assert.False(x != x);
            Assert.False(x.Equals(null));
            Assert.False(Equals(null, x));

            // ReSharper disable once HeuristicUnreachableCode
            Assert.Equal(x.GetHashCode(), x.GetHashCode());
            // ReSharper restore EqualExpressionComparison
#pragma warning restore 1718
        }

        [Fact]
        public void Value_objects_with_equal_members_are_equal()
        {
            var customRefType = new CustomRefType("qwer");
            var x = new ValueType("asdf", 42, true, customRefType, new ValueType2("xyz"));
            var y = new ValueType("asdf", 42, false, customRefType, new ValueType2("xyz"));

            Assert.True(x.Equals(y));
            Assert.True(y.Equals(x));
            Assert.True(x == y);
            Assert.False(x != y);

            Assert.Equal(x.GetHashCode(), y.GetHashCode());
        }

        [Fact]
        public void Contained_reference_types_are_compared_by_reference()
        {
            // The second CustomRefType is different from the first
            var x = new ValueType("asdf", 42, true, new CustomRefType("qwer"), new ValueType2("xyz"));
            var y = new ValueType("asdf", 42, true, new CustomRefType("qwer"), new ValueType2("xyz"));

            Assert.False(x.Equals(y));
            Assert.False(y.Equals(x));
            Assert.False(x == y);
            Assert.True(x != y);

            Assert.NotEqual(x.GetHashCode(), y.GetHashCode());
        }

        [Fact]
        public void Sequences_are_compared_element_by_element()
        {
            var x = new ValueTypeWithSequence(ImmutableList.Create(new ValueType2("a"), new ValueType2("b")));
            var y = new ValueTypeWithSequence(ImmutableList.Create(new ValueType2("a"), new ValueType2("b")));

            Assert.True(x.Equals(y));
            Assert.True(y.Equals(x));
            Assert.True(x == y);
            Assert.False(x != y);

            Assert.Equal(x.GetHashCode(), y.GetHashCode());
        }

        [Fact]
        public void Null_values_do_not_throw_exceptions_in_equals_and_getHashCode()
        {
            var x = new ValueType("asdf", 42, true, null, new ValueType2("xyz"));
            var y = new ValueType("asdf", 42, true, null, new ValueType2("xyz"));

            Assert.True(x.Equals(y));
            Assert.True(y.Equals(x));
            Assert.True(x == y);
            Assert.False(x != y);

            Assert.Equal(x.GetHashCode(), y.GetHashCode());
        }

        [Fact]
        public void Hash_codes_distribute()
        {
            var ints = Enumerable.Range(0, 40).ToList();
            var objs = ints.Select(i => new ValueType3(i)).ToList();

            Assert.Equal(ints.Count, new HashSet<ValueType3>(objs).Count);
        }

        [Fact]
        public void Dictionary_members_are_used_correctly_for_equality_comparison()
        {
            var x = new DictionaryType(new Dictionary<string, string> { { "a", "The A" }, { "b", "The B" } });
            var y = new DictionaryType(new Dictionary<string, string> { { "a", "The A" }, { "b", "The B" } });

            Assert.True(x.Equals(y));
            Assert.True(y.Equals(x));
            Assert.True(x == y);
            Assert.False(x != y);

            Assert.Equal(x.GetHashCode(), y.GetHashCode());
        }

        [Fact]
        public void Inherited_members_are_compared()
        {
            var x1 = new SubValueType1(12, 34);
            var x2 = new SubValueType1(12, 34);

            Assert.Equal(x1, x2);

            // WARNING: Base class members are not considered in the equality comparison, so the following object is considered
            // equal to x1 and x2. To work around this issue, add all equality comparison relevant members to the concrete classes
            // as well, or use a custom equality comparer.
            var y = new SubValueType1(99, 34);
            Assert.Equal(x1, y);
        }

        [Fact]
        public void Empty_value_types_dont_throw()
        {
            var x1 = new EmptyValueType();
            var x2 = new EmptyValueType();

            Assert.Equal(x1, x2);
        }

        [Fact]
        public void Ignoring_auto_properties_excludes_them_from_equality_comparison()
        {
            var v1 = new ValueType4(15, 62);
            var v2 = new ValueType4(15, 13);

            Assert.Equal(v1, v2);
        }

        // ReSharper disable NotAccessedField.Local
        private class ValueType : MemberwiseEquatable<ValueType>
        {
            private readonly string _value1;

            private readonly int _value2;

            [MemberwiseEqualityIgnore]
            private readonly bool _value3;

            private readonly CustomRefType _value4;

            private readonly ValueType2 _value5;

            public ValueType(string value1, int value2, bool value3, CustomRefType value4, ValueType2 value5)
            {
                _value1 = value1;
                _value2 = value2;
                _value3 = value3;
                _value4 = value4;
                _value5 = value5;
            }
        }

        private class ValueType2 : MemberwiseEquatable<ValueType2>
        {
            private readonly string _s;

            public ValueType2(string s)
            {
                _s = s;
            }
        }

        private class ValueType3 : MemberwiseEquatable<ValueType3>
        {
            public ValueType3(int value)
            {
                Value = value;
            }

            public int Value { get; }
        }

        private class ValueType4 : MemberwiseEquatable<ValueType4>
        {
            public ValueType4(int value, int ignoredValue)
            {
                Value = value;
                IgnoredValue = ignoredValue;
            }

            public int Value { get; }

            [MemberwiseEqualityIgnore]
            public int IgnoredValue { get; }
        }

        private class DictionaryType : MemberwiseEquatable<DictionaryType>
        {
            private readonly IDictionary<string, string> _dict;

            public DictionaryType(IDictionary<string, string> dict)
            {
                _dict = dict;
            }
        }

        private class CustomRefType
        {
            private readonly string _s;

            public CustomRefType(string s)
            {
                _s = s;
            }
        }

        private class ValueTypeWithSequence : MemberwiseEquatable<ValueTypeWithSequence>
        {
            private IReadOnlyList<ValueType2> _values;

            public ValueTypeWithSequence(IReadOnlyList<ValueType2> values)
            {
                _values = values;
            }
        }

        private abstract class AbstractValueType<TSelf> : MemberwiseEquatable<TSelf>
        {
            private readonly int _val1;

            protected AbstractValueType(int val1)
            {
                _val1 = val1;
            }
        }

        private class EmptyValueType : MemberwiseEquatable<EmptyValueType> { }

        private class SubValueType1 : AbstractValueType<SubValueType1>
        {
            private readonly int _val2;

            public SubValueType1(int val1, int val2)
                : base(val1)
            {
                _val2 = val2;
            }
        }

        private class SubValueType2 : AbstractValueType<SubValueType2>
        {
            private readonly int _val2;

            public SubValueType2(int val1, int val2)
                : base(val1)
            {
                _val2 = val2;
            }
        }

        // ReSharper restore NotAccessedField.Local
    }
}


text:
layout: post
title: "Kochi Ruby Meetup - 19 July, 2015"
date:  2015-07-15 14:00:00
categories: meetups
---

[Kerala Ruby User Group](http://krug.github.io) is for all the rubyists from Kerala who have immense passion for this wonderful language. Here we can share our experiences in using Ruby and discuss other aspects of this language. We host regular meetups in Kochi and Techopark, Trivandrum.

**RSVP**: [Google+](https://plus.google.com/events/cdhv1hpgv7qk74kolme9ah73800)

# Agenda

* Comparing Phoenix framework with Rails (Nithin Bekal)
* Other talks to be announced

**Date**: 2-5pm, 19 July, 2015

**Venue**: Red Panthers Software, Chembumukku

### Address

Red Panthers Software Solutions,
3rd Floor, Vijaya Complex,
Chembumukku, Kakkanad,
Cochin - 682030.

Landmark: Same building as Federal Bank, chembumukku branch.

Bus Stop: Chembumukku. (The office is on the road side, close to the bus stand).

<iframe src="https://www.google.com/maps/embed?pb=!1m14!1m8!1m3!1d491.13368008387215!2d76.32293928472673!3d10.011123013051687!3m2!1i1024!2i768!4f13.1!3m3!1m2!1s0x3b080cfc6e54aa05%3A0xad82389814ee4d11!2sRed+Panthers!5e0!3m2!1sen!2sin!4v1426303712881" width="600" height="450" frameborder="0" style="border:0"></iframe>