text:
import React from 'react';
import { SplitContentLayout } from '@bandwidth/shared-components';

export default ({ count = 20, activeIndex = 5 }) => (
  <SplitContentLayout.SecondaryContent.SidebarList>
    {new Array(count).fill(null).map((_, idx) => (
      <SplitContentLayout.SecondaryContent.SidebarList.Item
        key={idx}
        active={idx === activeIndex}
      >
        <SplitContentLayout.SecondaryContent.SidebarList.Item.Label>
          Item {idx}
        </SplitContentLayout.SecondaryContent.SidebarList.Item.Label>
        <SplitContentLayout.SecondaryContent.SidebarList.Item.Details>
          Details {idx}
        </SplitContentLayout.SecondaryContent.SidebarList.Item.Details>
      </SplitContentLayout.SecondaryContent.SidebarList.Item>
    ))}
  </SplitContentLayout.SecondaryContent.SidebarList>
);

redpajama_set_name: RedPajamaGithub


text:
layout: page
title: "Регрессия"
description: "Регрессия"
---

Рано или поздно каждый человек начинает задаваться вопросом "Почему я живу так, как живу?" И чем глубже он погружается в исследование зависимостей между событиями своей жизни и своим поведением, образом жизни и мысли, тем глубже начинает погружается в познание себя, своей природы, природы своих поступков и ценностей, в законы кармы.

В какой-то момент человек приходит к ощущению, что жизнь, которую он живет, далеко не первая и не последняя и тогда появляется сначала интерес, а позже и осознание необходимости узнать себя лучше.

Именно так однажды я сама пришла на сеанс регрессии в прошлую жизнь.

И конечно же ваша история может быть совсем иной, но есть общее, что их объединяет: желание познать себя.

Наша душа бессмертна и помнит каждое наше воплощение во всех мирах. Регрессия в прошлые жизни позволяет нам вспомнить, кем мы были, что делали, какие ценности исповедовали, какие ошибки совершали, каким потенциалом обладали и как его реализовывали. Весь этот опыт наша душа помнит, накопленная карма следует за нашей душой из воплощения в воплощение, уроки и страхи могут прорабатываться не одну жизнь подряд. И чем раньше мы осознаем, какие уроки и задачи выбрала наша душа для нашего нынешнего воплощения, тем большего сможем достичь на своем пути, тем более развитыми мы можем стать.

Регрессия в прошлые жизни — не панацея, но тем не менее это мощный и действенный инструмент для работы с более глубинными проявлениями нас. Это возможность исцелить свою душу и даже тело, изменить взаимоотношения с миром, близкими людьми, раскрыть свой потенциал, иногда даже получить знания или ценный совет.

Во время сеанса есть возможность пообщаться со своим Духом Наставником и задать ему важные на сегодняшний момент вопросы, и, что самое главное, получить на них ответы.

Если вам не просто интересно узнать, кем вы были, но вы понимаете, зачем вам это знание и чем оно вам поможет, я с радостью стану вашим проводником в пространство вашей души!

Стоимость часа моей работы 3000р.


text:
namespace SignalR.HubStrong.Tests.HubForTests
{
    using Microsoft.AspNet.SignalR;
    using SignalR.HubStrong.Tests.Contracts;
    using System;
    using System.Collections.Generic;

    public class TestHub : Hub<ITestHubClient>, ITestHub
    {
        public void CallHello()
        {
            Clients.All.Hello();
        }

        public void CallArgsMethods(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6, object arg7)
        {
            Clients.All.Args0();
            Clients.All.Args1(arg1);
            Clients.All.Args2(arg1, arg2);
            Clients.All.Args3(arg1, arg2, arg3);
            Clients.All.Args4(arg1, arg2, arg3, arg4);
            Clients.All.Args5(arg1, arg2, arg3, arg4, arg5);
            Clients.All.Args6(arg1, arg2, arg3, arg4, arg5, arg6);
            Clients.All.Args7(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }

        public void CallMultipleParamTypes(int intParam, long longParam, bool boolParam, string stringParam, string[] arrayParam, Dictionary<string, int> dictionaryParam, Foo objectParam)
        {
            Clients.All.MultipleParamTypes(intParam, longParam, boolParam, stringParam, arrayParam, dictionaryParam, objectParam);
        }

        public void DoFoo(string value)
        {
            Clients.All.Foo(value);
        }

        public string DoFooAndReturnValue(string value)
        {
            DoFoo(value);
            return value;
        }

        public void DoFooAndReportProgress(string value, IProgress<int> onProgress)
        {
            onProgress.Report(100);
            DoFoo(value);
        }

        public string DoFooAndReportProgressAndReturnValue(string value, IProgress<int> onProgress)
        {
            DoFooAndReportProgress(value, onProgress);
            return value;
        }
    }
}


text:
using NMF.Collections.Generic;
using NMF.Collections.ObjectModel;
using NMF.Expressions;
using NMF.Expressions.Linq;
using NMF.Models;
using NMF.Models.Collections;
using NMF.Models.Expressions;
using NMF.Models.Meta;
using NMF.Models.Repository;
using NMF.Serialization;
using NMF.Utilities;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using TTC2017.SmartGrids.CIM;
using TTC2017.SmartGrids.CIM.IEC61968.Common;
using TTC2017.SmartGrids.CIM.IEC61968.Customers;
using TTC2017.SmartGrids.CIM.IEC61968.Metering;
using TTC2017.SmartGrids.CIM.IEC61968.PaymentMetering;
using TTC2017.SmartGrids.CIM.IEC61970.Core;
using TTC2017.SmartGrids.CIM.IEC61970.Informative.InfCommon;

namespace TTC2017.SmartGrids.CIM.IEC61970.Informative.InfPaymentMetering
{

    /// <summary>
    /// The default implementation of the SDPAccountingFunction class
    /// </summary>
    [XmlNamespaceAttribute("http://iec.ch/TC57/2009/CIM-schema-cim14#InfPaymentMetering")]
    [XmlNamespacePrefixAttribute("cimInfPaymentMetering")]
    [ModelRepresentationClassAttribute("http://iec.ch/TC57/2009/CIM-schema-cim14#//IEC61970/Informative/InfPaymentMeterin" +
        "g/SDPAccountingFunction")]
    [DebuggerDisplayAttribute("SDPAccountingFunction {UUID}")]
    public partial class SDPAccountingFunction : DeviceFunction, ISDPAccountingFunction, IModelElement
    {

        private static Lazy<ITypedElement> _availableCreditReference = new Lazy<ITypedElement>(RetrieveAvailableCreditReference);

        /// <summary>
        /// The backing field for the AvailableCredit property
        /// </summary>
        private IAccountingUnit _availableCredit;

        private static Lazy<ITypedElement> _creditRegistersReference = new Lazy<ITypedElement>(RetrieveCreditRegistersReference);

        /// <summary>
        /// The backing field for the CreditRegisters property
        /// </summary>
        private SDPAccountingFunctionCreditRegistersCollection _creditRegisters;

        private static Lazy<ITypedElement> _chargeRegistersReference = new Lazy<ITypedElement>(RetrieveChargeRegistersReference);

        /// <summary>
        /// The backing field for the ChargeRegisters property
        /// </summary>
        private SDPAccountingFunctionChargeRegistersCollection _chargeRegisters;

        private static Lazy<ITypedElement> _lowCreditWarningLevelReference = new Lazy<ITypedElement>(RetrieveLowCreditWarningLevelReference);

        /// <summary>
        /// The backing field for the LowCreditWarningLevel property
        /// </summary>
        private IAccountingUnit _lowCreditWarningLevel;

        private static Lazy<ITypedElement> _creditExpiryLevelReference = new Lazy<ITypedElement>(RetrieveCreditExpiryLevelReference);

        /// <summary>
        /// The backing field for the CreditExpiryLevel property
        /// </summary>
        private IAccountingUnit _creditExpiryLevel;

        private static Lazy<ITypedElement> _serviceKindReference = new Lazy<ITypedElement>(RetrieveServiceKindReference);

        /// <summary>
        /// The backing field for the ServiceKind property
        /// </summary>
        private IServiceCategory _serviceKind;

        private static IClass _classInstance;

        public SDPAccountingFunction()
        {
            this._creditRegisters = new SDPAccountingFunctionCreditRegistersCollection(this);
            this._creditRegisters.CollectionChanging += this.CreditRegistersCollectionChanging;
            this._creditRegisters.CollectionChanged += this.CreditRegistersCollectionChanged;
            this._chargeRegisters = new SDPAccountingFunctionChargeRegistersCollection(this);
            this._chargeRegisters.CollectionChanging += this.ChargeRegistersCollectionChanging;
            this._chargeRegisters.CollectionChanged += this.ChargeRegistersCollectionChanged;
        }

        /// <summary>
        /// The availableCredit property
        /// </summary>
        [XmlElementNameAttribute("availableCredit")]
        [XmlAttributeAttribute(true)]
        public virtual IAccountingUnit AvailableCredit
        {
            get
            {
                return this._availableCredit;
            }
            set
            {
                if ((this._availableCredit != value))
                {
                    IAccountingUnit old = this._availableCredit;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnAvailableCreditChanging(e);
                    this.OnPropertyChanging("AvailableCredit", e, _availableCreditReference);
                    this._availableCredit = value;
                    if ((old != null))
                    {
                        old.Deleted -= this.OnResetAvailableCredit;
                    }
                    if ((value != null))
                    {
                        value.Deleted += this.OnResetAvailableCredit;
                    }
                    this.OnAvailableCreditChanged(e);
                    this.OnPropertyChanged("AvailableCredit", e, _availableCreditReference);
                }
            }
        }

        /// <summary>
        /// The CreditRegisters property
        /// </summary>
        [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content)]
        [XmlAttributeAttribute(true)]
        [XmlOppositeAttribute("SDPAccountingFunction")]
        [ConstantAttribute()]
        public virtual IOrderedSetExpression<ICreditRegister> CreditRegisters
        {
            get
            {
                return this._creditRegisters;
            }
        }

        /// <summary>
        /// The ChargeRegisters property
        /// </summary>
        [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content)]
        [XmlAttributeAttribute(true)]
        [XmlOppositeAttribute("SPAccountingFunction")]
        [ConstantAttribute()]
        public virtual IOrderedSetExpression<IChargeRegister> ChargeRegisters
        {
            get
            {
                return this._chargeRegisters;
            }
        }

        /// <summary>
        /// The lowCreditWarningLevel property
        /// </summary>
        [XmlElementNameAttribute("lowCreditWarningLevel")]
        [XmlAttributeAttribute(true)]
        public virtual IAccountingUnit LowCreditWarningLevel
        {
            get
            {
                return this._lowCreditWarningLevel;
            }
            set
            {
                if ((this._lowCreditWarningLevel != value))
                {
                    IAccountingUnit old = this._lowCreditWarningLevel;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnLowCreditWarningLevelChanging(e);
                    this.OnPropertyChanging("LowCreditWarningLevel", e, _lowCreditWarningLevelReference);
                    this._lowCreditWarningLevel = value;
                    if ((old != null))
                    {
                        old.Deleted -= this.OnResetLowCreditWarningLevel;
                    }
                    if ((value != null))
                    {
                        value.Deleted += this.OnResetLowCreditWarningLevel;
                    }
                    this.OnLowCreditWarningLevelChanged(e);
                    this.OnPropertyChanged("LowCreditWarningLevel", e, _lowCreditWarningLevelReference);
                }
            }
        }

        /// <summary>
        /// The creditExpiryLevel property
        /// </summary>
        [XmlElementNameAttribute("creditExpiryLevel")]
        [XmlAttributeAttribute(true)]
        public virtual IAccountingUnit CreditExpiryLevel
        {
            get
            {
                return this._creditExpiryLevel;
            }
            set
            {
                if ((this._creditExpiryLevel != value))
                {
                    IAccountingUnit old = this._creditExpiryLevel;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnCreditExpiryLevelChanging(e);
                    this.OnPropertyChanging("CreditExpiryLevel", e, _creditExpiryLevelReference);
                    this._creditExpiryLevel = value;
                    if ((old != null))
                    {
                        old.Deleted -= this.OnResetCreditExpiryLevel;
                    }
                    if ((value != null))
                    {
                        value.Deleted += this.OnResetCreditExpiryLevel;
                    }
                    this.OnCreditExpiryLevelChanged(e);
                    this.OnPropertyChanged("CreditExpiryLevel", e, _creditExpiryLevelReference);
                }
            }
        }

        /// <summary>
        /// The ServiceKind property
        /// </summary>
        [XmlAttributeAttribute(true)]
        [XmlOppositeAttribute("SPAccountingFunctions")]
        public virtual IServiceCategory ServiceKind
        {
            get
            {
                return this._serviceKind;
            }
            set
            {
                if ((this._serviceKind != value))
                {
                    IServiceCategory old = this._serviceKind;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnServiceKindChanging(e);
                    this.OnPropertyChanging("ServiceKind", e, _serviceKindReference);
                    this._serviceKind = value;
                    if ((old != null))
                    {
                        old.SPAccountingFunctions.Remove(this);
                        old.Deleted -= this.OnResetServiceKind;
                    }
                    if ((value != null))
                    {
                        value.SPAccountingFunctions.Add(this);
                        value.Deleted += this.OnResetServiceKind;
                    }
                    this.OnServiceKindChanged(e);
                    this.OnPropertyChanged("ServiceKind", e, _serviceKindReference);
                }
            }
        }

        /// <summary>
        /// Gets the referenced model elements of this model element
        /// </summary>
        public override IEnumerableExpression<IModelElement> ReferencedElements
        {
            get
            {
                return base.ReferencedElements.Concat(new SDPAccountingFunctionReferencedElementsCollection(this));
            }
        }

        /// <summary>
        /// Gets the Class model for this type
        /// </summary>
        public new static IClass ClassInstance
        {
            get
            {
                if ((_classInstance == null))
                {
                    _classInstance = ((IClass)(MetaRepository.Instance.Resolve("http://iec.ch/TC57/2009/CIM-schema-cim14#//IEC61970/Informative/InfPaymentMeterin" +
                            "g/SDPAccountingFunction")));
                }
                return _classInstance;
            }
        }

        /// <summary>
        /// Gets fired before the AvailableCredit property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> AvailableCreditChanging;

        /// <summary>
        /// Gets fired when the AvailableCredit property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> AvailableCreditChanged;

        /// <summary>
        /// Gets fired before the LowCreditWarningLevel property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> LowCreditWarningLevelChanging;

        /// <summary>
        /// Gets fired when the LowCreditWarningLevel property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> LowCreditWarningLevelChanged;

        /// <summary>
        /// Gets fired before the CreditExpiryLevel property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> CreditExpiryLevelChanging;

        /// <summary>
        /// Gets fired when the CreditExpiryLevel property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> CreditExpiryLevelChanged;

        /// <summary>
        /// Gets fired before the ServiceKind property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ServiceKindChanging;

        /// <summary>
        /// Gets fired when the ServiceKind property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ServiceKindChanged;

        private static ITypedElement RetrieveAvailableCreditReference()
        {
            return ((ITypedElement)(((ModelElement)(SDPAccountingFunction.ClassInstance)).Resolve("availableCredit")));
        }

        /// <summary>
        /// Raises the AvailableCreditChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnAvailableCreditChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.AvailableCreditChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the AvailableCreditChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnAvailableCreditChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.AvailableCreditChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Handles the event that the AvailableCredit property must reset
        /// </summary>
        /// <param name="sender">The object that sent this reset request</param>
        /// <param name="eventArgs">The event data for the reset event</param>
        private void OnResetAvailableCredit(object sender, System.EventArgs eventArgs)
        {
            this.AvailableCredit = null;
        }

        private static ITypedElement RetrieveCreditRegistersReference()
        {
            return ((ITypedElement)(((ModelElement)(SDPAccountingFunction.ClassInstance)).Resolve("CreditRegisters")));
        }

        /// <summary>
        /// Forwards CollectionChanging notifications for the CreditRegisters property to the parent model element
        /// </summary>
        /// <param name="sender">The collection that raised the change</param>
        /// <param name="e">The original event data</param>
        private void CreditRegistersCollectionChanging(object sender, NMF.Collections.ObjectModel.NotifyCollectionChangingEventArgs e)
        {
            this.OnCollectionChanging("CreditRegisters", e, _creditRegistersReference);
        }

        /// <summary>
        /// Forwards CollectionChanged notifications for the CreditRegisters property to the parent model element
        /// </summary>
        /// <param name="sender">The collection that raised the change</param>
        /// <param name="e">The original event data</param>
        private void CreditRegistersCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            this.OnCollectionChanged("CreditRegisters", e, _creditRegistersReference);
        }

        private static ITypedElement RetrieveChargeRegistersReference()
        {
            return ((ITypedElement)(((ModelElement)(SDPAccountingFunction.ClassInstance)).Resolve("ChargeRegisters")));
        }

        /// <summary>
        /// Forwards CollectionChanging notifications for the ChargeRegisters property to the parent model element
        /// </summary>
        /// <param name="sender">The collection that raised the change</param>
        /// <param name="e">The original event data</param>
        private void ChargeRegistersCollectionChanging(object sender, NMF.Collections.ObjectModel.NotifyCollectionChangingEventArgs e)
        {
            this.OnCollectionChanging("ChargeRegisters", e, _chargeRegistersReference);
        }

        /// <summary>
        /// Forwards CollectionChanged notifications for the ChargeRegisters property to the parent model element
        /// </summary>
        /// <param name="sender">The collection that raised the change</param>
        /// <param name="e">The original event data</param>
        private void ChargeRegistersCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            this.OnCollectionChanged("ChargeRegisters", e, _chargeRegistersReference);
        }

        private static ITypedElement RetrieveLowCreditWarningLevelReference()
        {
            return ((ITypedElement)(((ModelElement)(SDPAccountingFunction.ClassInstance)).Resolve("lowCreditWarningLevel")));
        }

        /// <summary>
        /// Raises the LowCreditWarningLevelChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnLowCreditWarningLevelChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.LowCreditWarningLevelChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the LowCreditWarningLevelChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnLowCreditWarningLevelChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.LowCreditWarningLevelChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Handles the event that the LowCreditWarningLevel property must reset
        /// </summary>
        /// <param name="sender">The object that sent this reset request</param>
        /// <param name="eventArgs">The event data for the reset event</param>
        private void OnResetLowCreditWarningLevel(object sender, System.EventArgs eventArgs)
        {
            this.LowCreditWarningLevel = null;
        }

        private static ITypedElement RetrieveCreditExpiryLevelReference()
        {
            return ((ITypedElement)(((ModelElement)(SDPAccountingFunction.ClassInstance)).Resolve("creditExpiryLevel")));
        }

        /// <summary>
        /// Raises the CreditExpiryLevelChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnCreditExpiryLevelChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.CreditExpiryLevelChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the CreditExpiryLevelChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnCreditExpiryLevelChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.CreditExpiryLevelChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Handles the event that the CreditExpiryLevel property must reset
        /// </summary>
        /// <param name="sender">The object that sent this reset request</param>
        /// <param name="eventArgs">The event data for the reset event</param>
        private void OnResetCreditExpiryLevel(object sender, System.EventArgs eventArgs)
        {
            this.CreditExpiryLevel = null;
        }

        private static ITypedElement RetrieveServiceKindReference()
        {
            return ((ITypedElement)(((ModelElement)(SDPAccountingFunction.ClassInstance)).Resolve("ServiceKind")));
        }

        /// <summary>
        /// Raises the ServiceKindChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnServiceKindChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ServiceKindChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the ServiceKindChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnServiceKindChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ServiceKindChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Handles the event that the ServiceKind property must reset
        /// </summary>
        /// <param name="sender">The object that sent this reset request</param>
        /// <param name="eventArgs">The event data for the reset event</param>
        private void OnResetServiceKind(object sender, System.EventArgs eventArgs)
        {
            this.ServiceKind = null;
        }

        /// <summary>
        /// Gets the Model element collection for the given feature
        /// </summary>
        /// <returns>A non-generic list of elements</returns>
        /// <param name="feature">The requested feature</param>
        protected override System.Collections.IList GetCollectionForFeature(string feature)
        {
            if ((feature == "CREDITREGISTERS"))
            {
                return this._creditRegisters;
            }
            if ((feature == "CHARGEREGISTERS"))
            {
                return this._chargeRegisters;
            }
            return base.GetCollectionForFeature(feature);
        }

        /// <summary>
        /// Sets a value to the given feature
        /// </summary>
        /// <param name="feature">The requested feature</param>
        /// <param name="value">The value that should be set to that feature</param>
        protected override void SetFeature(string feature, object value)
        {
            if ((feature == "AVAILABLECREDIT"))
            {
                this.AvailableCredit = ((IAccountingUnit)(value));
                return;
            }
            if ((feature == "LOWCREDITWARNINGLEVEL"))
            {
                this.LowCreditWarningLevel = ((IAccountingUnit)(value));
                return;
            }
            if ((feature == "CREDITEXPIRYLEVEL"))
            {
                this.CreditExpiryLevel = ((IAccountingUnit)(value));
                return;
            }
            if ((feature == "SERVICEKIND"))
            {
                this.ServiceKind = ((IServiceCategory)(value));
                return;
            }
            base.SetFeature(feature, value);
        }

        /// <summary>
        /// Gets the property expression for the given attribute
        /// </summary>
        /// <returns>An incremental property expression</returns>
        /// <param name="attribute">The requested attribute in upper case</param>
        protected override NMF.Expressions.INotifyExpression<object> GetExpressionForAttribute(string attribute)
        {
            if ((attribute == "AvailableCredit"))
            {
                return new AvailableCreditProxy(this);
            }
            if ((attribute == "LowCreditWarningLevel"))
            {
                return new LowCreditWarningLevelProxy(this);
            }
            if ((attribute == "CreditExpiryLevel"))
            {
                return new CreditExpiryLevelProxy(this);
            }
            if ((attribute == "ServiceKind"))
            {
                return new ServiceKindProxy(this);
            }
            return base.GetExpressionForAttribute(attribute);
        }

        /// <summary>
        /// Gets the property expression for the given reference
        /// </summary>
        /// <returns>An incremental property expression</returns>
        /// <param name="reference">The requested reference in upper case</param>
        protected override NMF.Expressions.INotifyExpression<NMF.Models.IModelElement> GetExpressionForReference(string reference)
        {
            if ((reference == "AvailableCredit"))
            {
                return new AvailableCreditProxy(this);
            }
            if ((reference == "LowCreditWarningLevel"))
            {
                return new LowCreditWarningLevelProxy(this);
            }
            if ((reference == "CreditExpiryLevel"))
            {
                return new CreditExpiryLevelProxy(this);
            }
            if ((reference == "ServiceKind"))
            {
                return new ServiceKindProxy(this);
            }
            return base.GetExpressionForReference(reference);
        }

        /// <summary>
        /// Gets the Class for this model element
        /// </summary>
        public override IClass GetClass()
        {
            if ((_classInstance == null))
            {
                _classInstance = ((IClass)(MetaRepository.Instance.Resolve("http://iec.ch/TC57/2009/CIM-schema-cim14#//IEC61970/Informative/InfPaymentMeterin" +
                        "g/SDPAccountingFunction")));
            }
            return _classInstance;
        }

        /// <summary>
        /// The collection class to to represent the children of the SDPAccountingFunction class
        /// </summary>
        public class SDPAccountingFunctionReferencedElementsCollection : ReferenceCollection, ICollectionExpression<IModelElement>, ICollection<IModelElement>
        {

            private SDPAccountingFunction _parent;

            /// <summary>
            /// Creates a new instance
            /// </summary>
            public SDPAccountingFunctionReferencedElementsCollection(SDPAccountingFunction parent)
            {
                this._parent = parent;
            }

            /// <summary>
            /// Gets the amount of elements contained in this collection
            /// </summary>
            public override int Count
            {
                get
                {
                    int count = 0;
                    if ((this._parent.AvailableCredit != null))
                    {
                        count = (count + 1);
                    }
                    count = (count + this._parent.CreditRegisters.Count);
                    count = (count + this._parent.ChargeRegisters.Count);
                    if ((this._parent.LowCreditWarningLevel != null))
                    {
                        count = (count + 1);
                    }
                    if ((this._parent.CreditExpiryLevel != null))
                    {
                        count = (count + 1);
                    }
                    if ((this._parent.ServiceKind != null))
                    {
                        count = (count + 1);
                    }
                    return count;
                }
            }

            protected override void AttachCore()
            {
                this._parent.AvailableCreditChanged += this.PropagateValueChanges;
                this._parent.CreditRegisters.AsNotifiable().CollectionChanged += this.PropagateCollectionChanges;
                this._parent.ChargeRegisters.AsNotifiable().CollectionChanged += this.PropagateCollectionChanges;
                this._parent.LowCreditWarningLevelChanged += this.PropagateValueChanges;
                this._parent.CreditExpiryLevelChanged += this.PropagateValueChanges;
                this._parent.ServiceKindChanged += this.PropagateValueChanges;
            }

            protected override void DetachCore()
            {
                this._parent.AvailableCreditChanged -= this.PropagateValueChanges;
                this._parent.CreditRegisters.AsNotifiable().CollectionChanged -= this.PropagateCollectionChanges;
                this._parent.ChargeRegisters.AsNotifiable().CollectionChanged -= this.PropagateCollectionChanges;
                this._parent.LowCreditWarningLevelChanged -= this.PropagateValueChanges;
                this._parent.CreditExpiryLevelChanged -= this.PropagateValueChanges;
                this._parent.ServiceKindChanged -= this.PropagateValueChanges;
            }

            /// <summary>
            /// Adds the given element to the collection
            /// </summary>
            /// <param name="item">The item to add</param>
            public override void Add(IModelElement item)
            {
                if ((this._parent.AvailableCredit == null))
                {
                    IAccountingUnit availableCreditCasted = item.As<IAccountingUnit>();
                    if ((availableCreditCasted != null))
                    {
                        this._parent.AvailableCredit = availableCreditCasted;
                        return;
                    }
                }
                ICreditRegister creditRegistersCasted = item.As<ICreditRegister>();
                if ((creditRegistersCasted != null))
                {
                    this._parent.CreditRegisters.Add(creditRegistersCasted);
                }
                IChargeRegister chargeRegistersCasted = item.As<IChargeRegister>();
                if ((chargeRegistersCasted != null))
                {
                    this._parent.ChargeRegisters.Add(chargeRegistersCasted);
                }
                if ((this._parent.LowCreditWarningLevel == null))
                {
                    IAccountingUnit lowCreditWarningLevelCasted = item.As<IAccountingUnit>();
                    if ((lowCreditWarningLevelCasted != null))
                    {
                        this._parent.LowCreditWarningLevel = lowCreditWarningLevelCasted;
                        return;
                    }
                }
                if ((this._parent.CreditExpiryLevel == null))
                {
                    IAccountingUnit creditExpiryLevelCasted = item.As<IAccountingUnit>();
                    if ((creditExpiryLevelCasted != null))
                    {
                        this._parent.CreditExpiryLevel = creditExpiryLevelCasted;
                        return;
                    }
                }
                if ((this._parent.ServiceKind == null))
                {
                    IServiceCategory serviceKindCasted = item.As<IServiceCategory>();
                    if ((serviceKindCasted != null))
                    {
                        this._parent.ServiceKind = serviceKindCasted;
                        return;
                    }
                }
            }

            /// <summary>
            /// Clears the collection and resets all references that implement it.
            /// </summary>
            public override void Clear()
            {
                this._parent.AvailableCredit = null;
                this._parent.CreditRegisters.Clear();
                this._parent.ChargeRegisters.Clear();
                this._parent.LowCreditWarningLevel = null;
                this._parent.CreditExpiryLevel = null;
                this._parent.ServiceKind = null;
            }

            /// <summary>
            /// Gets a value indicating whether the given element is contained in the collection
            /// </summary>
            /// <returns>True, if it is contained, otherwise False</returns>
            /// <param name="item">The item that should be looked out for</param>
            public override bool Contains(IModelElement item)
            {
                if ((item == this._parent.AvailableCredit))
                {
                    return true;
                }
                if (this._parent.CreditRegisters.Contains(item))
                {
                    return true;
                }
                if (this._parent.ChargeRegisters.Contains(item))
                {
                    return true;
                }
                if ((item == this._parent.LowCreditWarningLevel))
                {
                    return true;
                }
                if ((item == this._parent.CreditExpiryLevel))
                {
                    return true;
                }
                if ((item == this._parent.ServiceKind))
                {
                    return true;
                }
                return false;
            }

            /// <summary>
            /// Copies the contents of the collection to the given array starting from the given array index
            /// </summary>
            /// <param name="array">The array in which the elements should be copied</param>
            /// <param name="arrayIndex">The starting index</param>
            public override void CopyTo(IModelElement[] array, int arrayIndex)
            {
                if ((this._parent.AvailableCredit != null))
                {
                    array[arrayIndex] = this._parent.AvailableCredit;
                    arrayIndex = (arrayIndex + 1);
                }
                IEnumerator<IModelElement> creditRegistersEnumerator = this._parent.CreditRegisters.GetEnumerator();
                try
                {
                    for (
                    ; creditRegistersEnumerator.MoveNext();
                    )
                    {
                        array[arrayIndex] = creditRegistersEnumerator.Current;
                        arrayIndex = (arrayIndex + 1);
                    }
                }
                finally
                {
                    creditRegistersEnumerator.Dispose();
                }
                IEnumerator<IModelElement> chargeRegistersEnumerator = this._parent.ChargeRegisters.GetEnumerator();
                try
                {
                    for (
                    ; chargeRegistersEnumerator.MoveNext();
                    )
                    {
                        array[arrayIndex] = chargeRegistersEnumerator.Current;
                        arrayIndex = (arrayIndex + 1);
                    }
                }
                finally
                {
                    chargeRegistersEnumerator.Dispose();
                }
                if ((this._parent.LowCreditWarningLevel != null))
                {
                    array[arrayIndex] = this._parent.LowCreditWarningLevel;
                    arrayIndex = (arrayIndex + 1);
                }
                if ((this._parent.CreditExpiryLevel != null))
                {
                    array[arrayIndex] = this._parent.CreditExpiryLevel;
                    arrayIndex = (arrayIndex + 1);
                }
                if ((this._parent.ServiceKind != null))
                {
                    array[arrayIndex] = this._parent.ServiceKind;
                    arrayIndex = (arrayIndex + 1);
                }
            }

            /// <summary>
            /// Removes the given item from the collection
            /// </summary>
            /// <returns>True, if the item was removed, otherwise False</returns>
            /// <param name="item">The item that should be removed</param>
            public override bool Remove(IModelElement item)
            {
                if ((this._parent.AvailableCredit == item))
                {
                    this._parent.AvailableCredit = null;
                    return true;
                }
                ICreditRegister creditRegisterItem = item.As<ICreditRegister>();
                if (((creditRegisterItem != null)
                            && this._parent.CreditRegisters.Remove(creditRegisterItem)))
                {
                    return true;
                }
                IChargeRegister chargeRegisterItem = item.As<IChargeRegister>();
                if (((chargeRegisterItem != null)
                            && this._parent.ChargeRegisters.Remove(chargeRegisterItem)))
                {
                    return true;
                }
                if ((this._parent.LowCreditWarningLevel == item))
                {
                    this._parent.LowCreditWarningLevel = null;
                    return true;
                }
                if ((this._parent.CreditExpiryLevel == item))
                {
                    this._parent.CreditExpiryLevel = null;
                    return true;
                }
                if ((this._parent.ServiceKind == item))
                {
                    this._parent.ServiceKind = null;
                    return true;
                }
                return false;
            }

            /// <summary>
            /// Gets an enumerator that enumerates the collection
            /// </summary>
            /// <returns>A generic enumerator</returns>
            public override IEnumerator<IModelElement> GetEnumerator()
            {
                return Enumerable.Empty<IModelElement>().Concat(this._parent.AvailableCredit).Concat(this._parent.CreditRegisters).Concat(this._parent.ChargeRegisters).Concat(this._parent.LowCreditWarningLevel).Concat(this._parent.CreditExpiryLevel).Concat(this._parent.ServiceKind).GetEnumerator();
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the availableCredit property
        /// </summary>
        private sealed class AvailableCreditProxy : ModelPropertyChange<ISDPAccountingFunction, IAccountingUnit>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public AvailableCreditProxy(ISDPAccountingFunction modelElement) :
                    base(modelElement, "availableCredit")
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override IAccountingUnit Value
            {
                get
                {
                    return this.ModelElement.AvailableCredit;
                }
                set
                {
                    this.ModelElement.AvailableCredit = value;
                }
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the lowCreditWarningLevel property
        /// </summary>
        private sealed class LowCreditWarningLevelProxy : ModelPropertyChange<ISDPAccountingFunction, IAccountingUnit>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public LowCreditWarningLevelProxy(ISDPAccountingFunction modelElement) :
                    base(modelElement, "lowCreditWarningLevel")
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override IAccountingUnit Value
            {
                get
                {
                    return this.ModelElement.LowCreditWarningLevel;
                }
                set
                {
                    this.ModelElement.LowCreditWarningLevel = value;
                }
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the creditExpiryLevel property
        /// </summary>
        private sealed class CreditExpiryLevelProxy : ModelPropertyChange<ISDPAccountingFunction, IAccountingUnit>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public CreditExpiryLevelProxy(ISDPAccountingFunction modelElement) :
                    base(modelElement, "creditExpiryLevel")
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override IAccountingUnit Value
            {
                get
                {
                    return this.ModelElement.CreditExpiryLevel;
                }
                set
                {
                    this.ModelElement.CreditExpiryLevel = value;
                }
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the ServiceKind property
        /// </summary>
        private sealed class ServiceKindProxy : ModelPropertyChange<ISDPAccountingFunction, IServiceCategory>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ServiceKindProxy(ISDPAccountingFunction modelElement) :
                    base(modelElement, "ServiceKind")
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override IServiceCategory Value
            {
                get
                {
                    return this.ModelElement.ServiceKind;
                }
                set
                {
                    this.ModelElement.ServiceKind = value;
                }
            }
        }
    }
}


text:
#define _GNU_SOURCE
#include "org_bridj_Platform.h"
#include "JNI.h"

#include "bridj.hpp"
#include <string.h>

#define STRING_SIG "Ljava/lang/String;"
#define NEW_STRING(x) (*env)->NewStringUTF(env, x)

//jclass gPlatform_utsnameClass = NULL;
//jmethodID gPlatform_utsnameConstr = NULL;

void initPlatformMethods(JNIEnv *env)
{
	/*gPlatform_utsnameClass = FIND_GLOBAL_CLASS("org/bridj/Platform$utsname");
	gPlatform_utsnameConstr = (*env)->GetMethodID(env, gPlatform_utsnameClass, "<init>",
		"(" STRING_SIG STRING_SIG STRING_SIG STRING_SIG STRING_SIG ")V"
	);*/
}

#define JNI_SIZEOF(type, escType) \
jint JNICALL Java_org_bridj_Platform_sizeOf_1 ## escType(JNIEnv *env, jclass clazz) { return sizeof(type); }

#define JNI_SIZEOF_t(type) JNI_SIZEOF(type ## _t, type ## _1t)

JNI_SIZEOF_t(size)
JNI_SIZEOF_t(time)
JNI_SIZEOF_t(wchar)
JNI_SIZEOF_t(ptrdiff)
JNI_SIZEOF(long, long)

JNIEXPORT jint JNICALL Java_org_bridj_Platform_getMaxDirectMappingArgCount(JNIEnv *env, jclass clazz) {
#if defined(_WIN64)
	return 16;
#elif defined(DC__OS_Darwin) && defined(DC__Arch_AMD64)
	return 4;//16;
#elif defined(DC__OS_Linux) && defined(DC__Arch_AMD64)
	return 4;
#elif defined(_WIN32)
	return 8;
#else
	return -1;
#endif
}

/*
#ifdef _WIN32
jobject JNICALL Java_org_bridj_Platform_uname(JNIEnv *env, jclass clazz) {
	return NULL;
}
#else

#include <sys/utsname.h>
jobject JNICALL Java_org_bridj_Platform_uname(JNIEnv *env, jclass clazz)
{
	initMethods(env);

	struct utsname name;
	uname(&name);
	return (*env)->NewObject(
		env,
		gPlatform_utsnameClass,
		gPlatform_utsnameConstr,
		NEW_STRING(name.sysname),
		NEW_STRING(name.nodename),
		NEW_STRING(name.release),
		NEW_STRING(name.version),
		NEW_STRING(name.machine)
	);
}
#endif
*/


text:
<!DOCTYPE html>

    <title>Wetter {{ wetter_com.title }}</title>

    {% load bootstrap3 %}
    <link href="{{ STATIC_URL }}css/pyweather.css" rel="stylesheet" type="text/css" media="screen">
    {% bootstrap_css %}
    {% bootstrap_javascript %}

{#
{{ page_title }}
#}
    {% bootstrap_messages %}
    {% block content %}
        dummy content
    {% endblock %}


text:
package com.github.epiicthundercat.tameablemobs.client.render;

import com.github.epiicthundercat.tameablemobs.Reference;
import com.github.epiicthundercat.tameablemobs.mobs.TameableSnowman;
import com.github.epiicthundercat.tameablemobs.models.ModelTameableSnowman;
import com.github.epiicthundercat.tameablemobs.models.layers.LayerTamedSnowmanHead;

import net.minecraft.client.renderer.entity.RenderLiving;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

@SideOnly(Side.CLIENT)
public class RenderTameableSnowman extends RenderLiving<TameableSnowman>
{
    private static final ResourceLocation SNOW_MAN_TEXTURES = new ResourceLocation(Reference.ID, "textures/entity/tameablesnowman.png");

    public RenderTameableSnowman(RenderManager renderManagerIn)
    {
        super(renderManagerIn, new ModelTameableSnowman(), 0.5F);
        this.addLayer(new LayerTamedSnowmanHead(this));
    }

    /**
     * Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
     */
    protected ResourceLocation getEntityTexture(TameableSnowman entity)
    {
        return SNOW_MAN_TEXTURES;
    }

    public ModelTameableSnowman getMainModel()
    {
        return (ModelTameableSnowman)super.getMainModel();
    }
}


text:
'use strict'
var net = require('net')
var EventEmitter = require('events').EventEmitter
var util = require('util')
var tpidefs = require('./tpi.js')

function EnvisaLink (config) {
  EventEmitter.call(this)
  this.options = {
    host: config.host,
    port: config.port,
    password: config.password,
    zones: config.zones,
    partitions: config.partitions
  }
  this.pollId = undefined
}

util.inherits(EnvisaLink, EventEmitter)
module.exports = EnvisaLink

EnvisaLink.prototype.connect = function () {
  var _this = this
  this.zones = {}
  this.partitions = {}
  this.users = {}
  this.systems = undefined
  this.shouldReconnect = true

  this.connection = net.createConnection({ port: this.options.port, host: this.options.host })

  this.connection.on('error', function (ex) {
    _this.emit('log-error', '' + ex)
    _this.emit('error', ex)
  })

  this.connection.on('close', function (hadError) {
    clearInterval(this.pollId)
    setTimeout(function () {
      if (_this.shouldReconnect && (_this.connection === undefined || _this.connection.destroyed)) {
        _this.connect()
      }
    }, 5000)
  })

  this.connection.on('end', function () {
    _this.emit('disconnect')
  })

  this.connection.on('data', function (data) {
    var dataslice = data.toString().replace(/[\n\r]/g, ',').split(',')

    for (var i = 0; i < dataslice.length; i++) {
      var datapacket = dataslice[i]
      if (datapacket !== '') {
        var tpi = tpidefs.tpicommands[datapacket.substring(0, 3)]
        if (tpi) {
          if (tpi.bytes === '' || tpi.bytes === 0) {
            _this.emit('log-warn', tpi.pre + ' - ' + tpi.post)
          } else {
            _this.emit('log-trace', tpi.pre + ' ' + datapacket.substring(3, datapacket.length - 2) + ' ' + tpi.post)
            if (tpi.action === 'updatezone') {
              updateZone(tpi, datapacket)
            } else if (tpi.action === 'updatepartition') {
              updatePartition(tpi, datapacket)
            } else if (tpi.action === 'updatepartitionuser') {
              updatePartitionUser(tpi, datapacket)
            } else if (tpi.action === 'updatesystem') {
              updateSystem(tpi, datapacket)
            } else if (tpi.action === 'loginresponse') {
              loginResponse(datapacket)
            }
          }
        }
      }
    }
  })

  function loginResponse (data) {
    var loginStatus = data.substring(3, 4)
    if (loginStatus === '0') {
      _this.emit('log-debug', 'Incorrect password')
    } else if (loginStatus === '1') {
      _this.emit('connected')
      _this.emit('log-trace', 'Successfully logged in. Requesting current state.')
      _this.sendCommand('001')
      clearInterval(_this.pollId)
      _this.pollId = setInterval(function () {
        _this.sendCommand('000')
      }, 60000)
    } else if (loginStatus === '2') {
      _this.emit('log-debug', 'Request for password timed out.')
    } else if (loginStatus === '3') {
      _this.emit('log-trace', 'Login requested. Sending response. ' + _this.options.password)
      _this.sendCommand('005' + _this.options.password)
    }
  }

  function updateZone (tpi, data) {
    var zone = parseInt(data.substring(3, 6))
    var initialUpdate = _this.zones[zone] === undefined
    _this.emit('log-trace', 'Zone: ' + zone + ', options: ' + _this.options.zones)
    if (zone <= _this.options.zones) {
      _this.zones[zone] = { send: tpi.send, name: tpi.name, code: data }
      _this.emit('zoneupdate',
        { zone: parseInt(data.substring(3, 6)),
          code: data.substring(0, 3),
          status: tpi.name,
          initialUpdate: initialUpdate })
    }
  }

  function updatePartition (tpi, data) {
    var partition = parseInt(data.substring(3, 4))
    var initialUpdate = _this.partitions[partition] === undefined
    if (partition <= _this.options.partitions) {
      _this.partitions[partition] = { send: tpi.send, name: tpi.name, code: data }
      if (data.substring(0, 3) === '652') {
        var modeCode = data.substring(4, 5)
        var mode = modeToHumanReadable(modeCode)
        _this.emit('partitionupdate',
          { partition: parseInt(data.substring(3, 4)),
            code: data.substring(0, 3),
            modeCode: modeCode,
            mode: mode,
            status: tpi.name,
            initialUpdate: initialUpdate })
      } else {
        _this.emit('partitionupdate',
          { partition: parseInt(data.substring(3, 4)),
            code: data.substring(0, 3),
            status: tpi.name,
            initialUpdate: initialUpdate })
      }
    }
  }

  function modeToHumanReadable (mode) {
    if (mode === 0) return 'AWAY'
    else if (mode === 1) return 'STAY'
    else if (mode === 2) return 'ZERO-ENTRY-AWAY'
    else return 'ZERO-ENTRY-STAY'
  }

  function updatePartitionUser (tpi, data) {
    var partition = parseInt(data.substring(3, 4))
    var user = parseInt(data.substring(4, 8))
    var initialUpdate = _this.users[user] === undefined
    if (partition <= _this.options.partitions) {
      _this.users[user] = { send: tpi.send, name: tpi.name, code: data }
      _this.emit('partitionuserupdate',
        { partition: parseInt(data.substring(3, 4)),
          code: data.substring(0, 3),
          user: user,
          status: tpi.name,
          initialUpdate: initialUpdate })
    }
  }

  function updateSystem (tpi, data) {
    _this.systems = { send: tpi.send, name: tpi.name, code: data }
    _this.emit('systemupdate', { code: data.substring(0, 3), status: tpi.name })
  }
}

EnvisaLink.prototype.disconnect = function () {
  clearInterval(this.pollId)
  this.shouldReconnect = false
  if (this.connection && !this.connection.destroyed) {
    this.connection.end()
    return false
  } else {
    return true
  }
}

EnvisaLink.prototype.sendCommand = function (command) {
  var checksum = 0
  for (var i = 0; i < command.length; i++) {
    checksum += command.charCodeAt(i)
  }

  checksum = checksum.toString(16).slice(-2).toUpperCase()
  this.connection.write(command + checksum + '\r\n')
}


text:
package org.mercycorps.translationcards;

import android.support.test.rule.ActivityTestRule;
import android.support.test.runner.AndroidJUnit4;
import android.test.suitebuilder.annotation.LargeTest;

import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mercycorps.translationcards.activity.DecksActivity;

import static android.support.test.espresso.Espresso.closeSoftKeyboard;
import static android.support.test.espresso.Espresso.onView;
import static android.support.test.espresso.action.ViewActions.click;
import static android.support.test.espresso.action.ViewActions.replaceText;
import static android.support.test.espresso.action.ViewActions.typeText;
import static android.support.test.espresso.assertion.PositionAssertions.isRightOf;
import static android.support.test.espresso.assertion.ViewAssertions.matches;
import static android.support.test.espresso.matcher.ViewMatchers.withId;
import static android.support.test.espresso.matcher.ViewMatchers.withText;
import static java.lang.Thread.sleep;

@RunWith(AndroidJUnit4.class)
@LargeTest
public class UserFlow {

    public static final String ORIGIN_TEXT = "Where does it hurt?";
    public static final String TRANSLATION_TEXT = "حيث أنها لا تؤذي؟";

    @Rule
    public ActivityTestRule<DecksActivity> activityTestRule = new ActivityTestRule<>(DecksActivity.class);

    @Test
    public void createAndDeleteCardFlow() throws InterruptedException {

        onView(withText("Default")).perform(click());

        onView(withId(R.id.add_button)).perform(click());
        onView(withId(R.id.recording_instructions_start)).perform(click());

        onView(withText("Flashcard phrase")).perform(typeText(ORIGIN_TEXT));
        closeSoftKeyboard();
        onView(withText("Phrase translation (Optional)")).perform(replaceText(TRANSLATION_TEXT));
        onView(withId(R.id.recording_label_next)).perform(click());

        onView(withId(R.id.recording_audio_button_record)).perform(click());
        sleep(2000);
        onView(withId(R.id.recording_audio_button_record)).perform(click());
        onView(withId(R.id.recording_audio_save)).perform(click());

        onView(withId(R.id.origin_translation_text)).check(matches(withText(ORIGIN_TEXT)));
        onView(withId(R.id.translated_text)).check(matches(withText(TRANSLATION_TEXT)));
        onView(withId(R.id.recording_done)).perform(click());

        onView(withId(R.id.indicator_icon)).check(isRightOf(withText(ORIGIN_TEXT))).perform(click());
        onView(withText("Delete this flashcard")).perform(click());
        onView(withText("OK")).perform(click());
    }
}


text:
This project allows to publish a regular WMS as a WMS-Q by wrapping the existing WMS server and adding quality-specific information and providing the same (meta)data through a WMS interface.

## Documentation

Project documentation: https://wiki.52north.org/bin/view/Geostatistics/WMSQServerFacade

WMS-Q:

## License

This projects is published under the Apache Software License, Version 2.0. See the NOTICE file for licenses of used libraries.


text:
{{< layout}}

{{$main-content}}

You need a digital photo

Get a friend to take one

They can use a phone, digital camera or tablet. You'll upload your photo online.

We'll show you how to take a good passport photo.

Go to a photo shop or booth

If you go to a photo shop, they'll send you an email with a link to start your application. We'll access your photo automatically.

If you use a booth, you'll need the digital photo code shown on your printed photos.

              Continue

{{/main-content}}

{{/ layout}}


text:
package com.kleine.genetic.algorithm;

import com.kleine.genetic.algorithm.predatorandprey.Prey;
import com.kleine.genetic.algorithm.predatorandprey.Snake;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Evaluates a list of snakes.
 */
public class Evaluator {

    /**
     * Evaluates the fitness of the snakes against the prey and returns the snakes mapped to their fitness.
     *
     * @param snakes the snakes that are being evaluated
     * @param prey the prey that the snakes are being tested with
     * @return the snakes mapped to their fitness in a Map
     */
    public Map<Snake, Float> evaluateSnakes(List<Snake> snakes, Prey prey) {
        //TODO initialise the map
        Map<Snake, Float> result = new HashMap<>();
        for(int i = 0; i < snakes.size(); i++) {
            Snake snake = snakes.get(i);
            float fitness = snake.catchPrey(prey);
            result.put(snake, fitness);
        }
        /**
         * TODO
         * - Use the catchPrey method of the snake to get the fitness value of the snake
         * - Put the snake and its fitness value into the map
         */
        return result;
    }
}


text:
namespace Azure.Security.KeyVault.Administration.Models
{
    /// <inheritdoc/>
    internal partial class RestoreOperationParameters
    { }
}


text:
'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

var _arity = require('./arity');

var _listRepeat = require('../list/repeat');

var _listSlice = require('../list/slice');

var throwError = function throwError() {
  throw new Error('First argument to nAry must be a non-negative integer no greater than ten');
};

var nAry = function nAry(n, fn) {
  return n > 10 ? throwError() : (0, _arity.arity)(n, function () {
    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return fn.apply(undefined, _toConsumableArray((0, _listSlice.slice)(0, n, args)).concat(_toConsumableArray((0, _listRepeat.repeat)(undefined, n - args.length))));
  });
};
exports.nAry = nAry;


text:
package com.handmark.pulltorefresh.library.internal;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.drawable.Drawable;
import android.view.View;
import com.handmark.pulltorefresh.library.PullToRefreshBase;
import com.handmark.pulltorefresh.library.R;

/**
 * Created by jiasheng on 14-4-4.
 */
public class ClipLoadingLayout extends LoadingLayout {

    public ClipLoadingLayout(Context context, PullToRefreshBase.Mode mode, PullToRefreshBase.Orientation scrollDirection, TypedArray attrs) {
        super(context, mode, scrollDirection, attrs);
    }

    @Override
    protected int getDefaultDrawableResId() {
        return R.drawable.pull_clip;
    }

    @Override
    protected void onLoadingDrawableSet(Drawable imageDrawable) {

    }

    @Override
    protected void onPullImpl(float scaleOfLayout) {
        if (2 * scaleOfLayout - 1 > 0)
            mHeaderImage.getDrawable().setLevel(Math.min(10000, (int) (20000 * scaleOfLayout - 10000)));
    }

    @Override
    protected void pullToRefreshImpl() {

    }

    @Override
    protected void refreshingImpl() {
        mHeaderProgress.setVisibility(View.VISIBLE);
        mHeaderImage.setVisibility(View.GONE);
    }

    @Override
    protected void releaseToRefreshImpl() {

    }

    @Override
    protected void resetImpl() {
        mHeaderProgress.setVisibility(View.GONE);
        mHeaderImage.setVisibility(View.VISIBLE);
        mHeaderImage.getDrawable().setLevel(0);
    }
}


text:
//----------------------------------------------------------------------------------------------------------------------
// Karma unit test configuration
//----------------------------------------------------------------------------------------------------------------------

module.exports = function(config)
{
    config.set({
        files: [
            'client/vendor/angular/angular.min.js',
            'client/vendor/angular-mocks/angular-mocks.js',
            'client/vendor/angular-route/angular-route.js',
            'client/vendor/babylonjs/babylon.2.0.js',
            'client/vendor/Keypress/keypress.js',
            'client/vendor/path/path.min.js',
            'client/vendor/eventemitter2/lib/eventemitter2.js',
            'client/vendor/bluebird/js/browser/bluebird.min.js',
            'client/vendor/lodash/lodash.min.js',
            'client/vendor/rfi-physics/dist/rfi-physics.js',
            'client/vendor/socket.io-client/socket.io.js',

            // App files to be tested
            'client/app.js',
            'client/components/**/*.js',
            'client/ui/**/*.js',

            // Tests
            'tests/**/*.spec.js'
        ],
        frameworks: ['jasmine'],
        browsers: ['Chrome', 'Firefox'],
        reporters: ['spec'],
        singleRun: true
    });
}; // end module.exports

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


text:
package org.apache.flink.types.parser;

public class BooleanParserTest extends ParserTestBase<Boolean> {

    @Override
    public String[] getValidTestValues() {
        return new String[] {"true", "false", "0", "1", "TRUE", "FALSE", "True", "False"};
    }

    @Override
    public Boolean[] getValidTestResults() {
        return new Boolean[] {true, false, false, true, true, false, true, false};
    }

    @Override
    public String[] getInvalidTestValues() {
        return new String[] {"yes", "no", "2", "-1", "wahr", "falsch", "", "asdf"};
    }

    @Override
    public boolean allowsEmptyField() {
        return false;
    }

    @Override
    public FieldParser<Boolean> getParser() {
        return new BooleanParser();
    }

    @Override
    public Class<Boolean> getTypeClass() {
        return Boolean.class;
    }
}


text:
package jetbrains.buildServer.clouds.azure;

import java.util.*;
import jetbrains.buildServer.clouds.CloudClientParameters;
import jetbrains.buildServer.clouds.CloudImageParameters;
import jetbrains.buildServer.clouds.models.FakeCloudImageDetails;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.testng.Assert;
import org.testng.annotations.Test;

/**
 * @author Dmitry.Tretyakov
 * Date: 3/2/2016
 * Time: 2:27 PM
 */
public class AzureUtilsTest {
  @Test
  public void parseImageDataTest() {

    Map<String, String> paramsMap = new HashMap<>();
    paramsMap.put("images_data", "[{\"data\":\"data\"}]");
    paramsMap.put("secure:passwords_data", "{\"name\":\"password\"}");
    final CloudClientParameters parameters = new MockCloudClientParameters(paramsMap);
    final Collection<FakeCloudImageDetails> images = AzureUtils.parseImageData(FakeCloudImageDetails.class, parameters);
    Assert.assertNotNull(images);

    final Iterator<FakeCloudImageDetails> iterator = images.iterator();
    Assert.assertTrue(iterator.hasNext());
    final FakeCloudImageDetails details = iterator.next();
    Assert.assertFalse(iterator.hasNext());
    Assert.assertNotNull(details);
    Assert.assertEquals(details.getData(), "data");
    Assert.assertEquals(details.getPassword(), "password");
  }

  @Test
  public void parseNewImageDataTest() {
    Map<String, String> paramsMap = new HashMap<>();
    paramsMap.put(CloudImageParameters.SOURCE_IMAGES_JSON, "[{\"data\":\"data\"}]");
    paramsMap.put("secure:passwords_data", "{\"name\":\"password\"}");
    final CloudClientParameters parameters = new MockCloudClientParameters(paramsMap);
    final Collection<FakeCloudImageDetails> images = AzureUtils.parseImageData(FakeCloudImageDetails.class, parameters);
    Assert.assertNotNull(images);

    final Iterator<FakeCloudImageDetails> iterator = images.iterator();
    Assert.assertTrue(iterator.hasNext());
    final FakeCloudImageDetails details = iterator.next();
    Assert.assertFalse(iterator.hasNext());
    Assert.assertNotNull(details);
    Assert.assertEquals(details.getData(), "data");
    Assert.assertEquals(details.getPassword(), "password");
  }

  private class MockCloudClientParameters extends CloudClientParameters {
    private final Map<String, String> myParameters;

    public MockCloudClientParameters(Map<String, String> parameters) {
      myParameters = parameters;
    }

    @Nullable
    @Override
    public String getParameter(@NotNull String s) {
      return myParameters.get(s);
    }

    @NotNull
    @Override
    public Collection<String> listParameterNames() {
      return myParameters.keySet();
    }

    @NotNull
    @Override
    public Collection<CloudImageParameters> getCloudImages() {
      return null;
    }

    @NotNull
    @Override
    public Map<String, String> getParameters() {
      return Collections.unmodifiableMap(myParameters);
    }

    @NotNull
    @Override
    public String getProfileId() {
      return null;
    }

    @NotNull
    @Override
    public String getProfileDescription() {
      return null;
    }
  }
}


text:
package org.kie.workbench.common.stunner.core.client.resources;

import org.kie.workbench.common.stunner.core.client.shape.ImageStripGlyph;

public interface StunnerCommonIconsGlyphFactory {

    ImageStripGlyph DELETE = ImageStripGlyph.create(StunnerCommonIconsStrip.class, 0);

    ImageStripGlyph GEARS = ImageStripGlyph.create(StunnerCommonIconsStrip.class, 1);

    ImageStripGlyph FORM = ImageStripGlyph.create(StunnerCommonIconsStrip.class, 2);

    ImageStripGlyph SUBPROCESS = ImageStripGlyph.create(StunnerCommonIconsStrip.class, 2);
}