text:
/**
 *  AES encrypted private key and display name. Contains Initialization Vectors,
 *  but not secrets. Used to encrypt private identities for storage on remote
 *  systems.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacCredential
 *  @module org.cassproject
 */
var EbacCredential = function() {
    EcLinkedData.call(this, Ebac.context, EbacCredential.TYPE_0_3);
};
EbacCredential = stjs.extend(EbacCredential, EcLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.1/credential";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/credential";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/Credential";
    /**
     *  AES Initialization Vector used to decode PPK. Base64 encoded.
     *  @property iv
     *  @type string
     */
    prototype.iv = null;
    /**
     *  AES encrypted Private Key in PEM form.
     *  @property ppk
     *  @type string
     */
    prototype.ppk = null;
    /**
     *  AES Initialization Vector used to decode displayName. Base64 encoded.
     *  @property displayNameIv
     *  @type string
     */
    prototype.displayNameIv = null;
    /**
     *  AES encrypted display name for identity.
     *  @property displayName
     *  @type string
     */
    prototype.displayName = null;
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacCredential.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacCredential.TYPE_0_2);
        }
        if (EbacCredential.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacCredential.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacCredential.TYPE_0_3);
        a.push(EbacCredential.TYPE_0_2);
        a.push(EbacCredential.TYPE_0_1);
        return a;
    };
}, {atProperties: {name: "Array", arguments: [null]}}, {});
/**
 *  Message used to retrieve credentials from a remote system.
 *
 *  TODO: Vulnerable to replay attacks.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacCredentialRequest
 *  @module org.cassproject
 */
var EbacCredentialRequest = function() {
    EcLinkedData.call(this, Ebac.context, EbacCredentialRequest.TYPE_0_3);
};
EbacCredentialRequest = stjs.extend(EbacCredentialRequest, EcLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.1/credentialRequest";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/credentialRequest";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/CredentialRequest";
    /**
     *  Hashed username.
     *  @property username
     *  @type string
     */
    prototype.username = null;
    /**
     *  Hashed password to authorize request.
     *  @property password
     *  @type string
     */
    prototype.password = null;
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacCredentialRequest.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacCredentialRequest.TYPE_0_2);
        }
        if (EbacCredentialRequest.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacCredentialRequest.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacCredentialRequest.TYPE_0_3);
        a.push(EbacCredentialRequest.TYPE_0_2);
        a.push(EbacCredentialRequest.TYPE_0_1);
        return a;
    };
}, {atProperties: {name: "Array", arguments: [null]}}, {});
/**
 *  Credential list along with one time pad and session-based token for use in
 *  commit actions.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacCredentials
 *  @module org.cassproject
 */
var EbacCredentials = function() {
    EcLinkedData.call(this, Ebac.context, EbacCredentials.TYPE_0_3);
};
EbacCredentials = stjs.extend(EbacCredentials, EcLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.1/credentials";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/credentials";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/Credentials";
    /**
     *  One time pad that may be used in password recovery. Base64 encoded.
     *  @property pad
     *  @type string
     */
    prototype.pad = null;
    /**
     *  Token provided by server to use in commit actions.
     *  @property token
     *  @type string
     */
    prototype.token = null;
    /**
     *  Credential array.
     *  @property credentials
     *  @type EbacCredential[]
     */
    prototype.credentials = null;
    /**
     *  Contact array.
     *  @property contacts
     *  @type EbacContact[]
     */
    prototype.contacts = null;
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacCredentials.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacCredentials.TYPE_0_2);
        }
        if (EbacCredentials.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacCredentials.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacCredentials.TYPE_0_3);
        a.push(EbacCredentials.TYPE_0_2);
        a.push(EbacCredentials.TYPE_0_1);
        return a;
    };
}, {credentials: {name: "Array", arguments: ["EbacCredential"]}, contacts: {name: "Array", arguments: ["EbacContact"]}, atProperties: {name: "Array", arguments: [null]}}, {});
/**
 *  AES encrypted public key and display name. Contains Initialization Vectors,
 *  but not secrets. Used to encrypt public identities for storage on remote
 *  systems.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacContact
 *  @module org.cassproject
 */
var EbacContact = function() {
    EcLinkedData.call(this, Ebac.context, EbacContact.TYPE_0_3);
};
EbacContact = stjs.extend(EbacContact, EcLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.2/contact";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/contact";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/Contact";
    /**
     *  AES Initialization Vector used to decode PPK. Base64 encoded.
     *  @property iv
     *  @type string
     */
    prototype.iv = null;
    /**
     *  AES encrypted Private Key in PEM format.
     *  @property pk
     *  @type string
     */
    prototype.pk = null;
    /**
     *  AES Initialization Vector used to decode displayName. Base64 encoded.
     *  @property displayNameIv
     *  @type string
     */
    prototype.displayNameIv = null;
    /**
     *  AES encrypted display name for identity.
     *  @property displayName
     *  @type string
     */
    prototype.displayName = null;
    /**
     *  AES Initialization Vector of the home server of the contact. Base64 encoded.
     *  @property sourceIv
     *  @type string
     */
    prototype.sourceIv = null;
    /**
     *  URL to the home server of the contact.
     *  @property source
     *  @type string
     */
    prototype.source = null;
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacContact.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacContact.TYPE_0_2);
        }
        if (EbacContact.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacContact.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacContact.TYPE_0_3);
        a.push(EbacContact.TYPE_0_2);
        a.push(EbacContact.TYPE_0_1);
        return a;
    };
}, {atProperties: {name: "Array", arguments: [null]}}, {});
/**
 *  Component of EbacEncryptedValue that contains data needed to decrypt
 *  encrypted payload. Is, itself, encrypted.
 *
 *  Also contains data used to verify that encrypted-data substitution attacks
 *  were not performed on the data.
 *
 *  Must be encryptable by RSA-2048, therefore, serialized form must less than 256
 *  bytes.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacEncryptedSecret
 *  @module org.cassproject
 */
var EbacEncryptedSecret = function() {
    EcLinkedData.call(this, Ebac.context, EbacEncryptedSecret.TYPE_0_3);
};
EbacEncryptedSecret = stjs.extend(EbacEncryptedSecret, EcLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.1/encryptedSecret";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/encryptedSecret";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/EncryptedSecret";
    /**
     *  IV used to encrypt/decrypt payload. Base64 encoded.
     *  @property iv
     *  @type string
     */
    prototype.iv = null;
    /**
     *  Hashed and Base64 encoded ID of the parent (if any) object.
     *  Used to verify the data has not been copied from elsewhere.
     *  @property id
     *  @type string
     */
    prototype.id = null;
    /**
     *  Secret used to encrypt/decrypt payload.
     *  @property secret
     *  @type string
     */
    prototype.secret = null;
    /**
     *  Dot and Bracket notated index of the field in the parent-most object (if
     *  any). Used to verify the field has not been copied from elsewhere.
     *  @property field
     *  @type string
     */
    prototype.field = null;
    /**
     *  Serializes the field into a compact form for RSA encryption.
     *  @method toEncryptableJson
     *  @return {string} string
     */
    prototype.toEncryptableJson = function() {
        var o = (new Object());
        o["v"] = this.iv;
        if (this.id != null)
            o["d"] = this.id;
        o["s"] = this.secret;
        if (this.field != null)
            o["f"] = this.field;
        return JSON.stringify(o);
    };
    /**
     *  Deserializes the field from a compact form used in RSA encryption.
     *  @method fromEncryptableJson
     *  @static
     *  @param {JSONObject} obj Object to deserialize from.
     *  @return {EbacEncryptedSecret} Secret in object form.
     */
    constructor.fromEncryptableJson = function(obj) {
        var secret = new EbacEncryptedSecret();
        var o = (obj);
        secret.iv = o["v"];
        if (o["d"] != null)
            secret.id = o["d"];
        secret.secret = o["s"];
        if (o["f"] != null)
            secret.field = o["f"];
        return secret;
    };
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacEncryptedSecret.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacEncryptedSecret.TYPE_0_2);
        }
        if (EbacEncryptedSecret.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacEncryptedSecret.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacEncryptedSecret.TYPE_0_3);
        a.push(EbacEncryptedSecret.TYPE_0_2);
        a.push(EbacEncryptedSecret.TYPE_0_1);
        return a;
    };
}, {atProperties: {name: "Array", arguments: [null]}}, {});
/**
 *  Signature used to authorize movement of data on behalf of a private-key
 *  holding owner.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacSignature
 *  @module org.cassproject
 */
var EbacSignature = function() {
    EcLinkedData.call(this, Ebac.context, EbacSignature.TYPE_0_3);
};
EbacSignature = stjs.extend(EbacSignature, EcLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.1/timeLimitedSignature";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/timeLimitedSignature";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/TimeLimitedSignature";
    /**
     *  The public key of the authorizing party in PEM format.
     *  @property owner
     *  @type string
     */
    prototype.owner = null;
    /**
     *  The time in number of milliseconds since midnight of January 1, 1970
     *  00:00:00 UTC that this signature is authorized to move data.
     *  @property expiry
     *  @type long
     */
    prototype.expiry = 0.0;
    /**
     *  The signature of this object, having signed the object, having been
     *  encoded in JSON with no space or tabs in ASCII sort order, having no
     *  value for the signature at the time of signing.
     *  @property signature
     *  @type string
     */
    prototype.signature = null;
    /**
     *  The server authorized to move data. If this is empty, the signature may
     *  be used by a server to ask for data from other servers.
     *  @property server
     *  @type string
     */
    prototype.server = null;
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacSignature.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacSignature.TYPE_0_2);
        }
        if (EbacSignature.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacSignature.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacSignature.TYPE_0_3);
        a.push(EbacSignature.TYPE_0_2);
        a.push(EbacSignature.TYPE_0_1);
        return a;
    };
}, {atProperties: {name: "Array", arguments: [null]}}, {});
/**
 *  Encrypted JSON-LD object or string.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacEncryptedValue
 *  @module org.cassproject
 */
var EbacEncryptedValue = function() {
    EcRemoteLinkedData.call(this, Ebac.context, EbacEncryptedValue.myType);
};
EbacEncryptedValue = stjs.extend(EbacEncryptedValue, EcRemoteLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.1/encryptedValue";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/encryptedValue";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/EncryptedValue";
    constructor.myType = EbacEncryptedValue.TYPE_0_3;
    /**
     *  Optional Hint used to aid in search.
     *  Displays the type of the encrypted object.
     *  @property encryptedType
     *  @type string
     */
    prototype.encryptedType = null;
    /**
     *  Base-64 encoded, AES encrypted form of the encrypted object (or string).
     *  @property payload
     *  @type string
     */
    prototype.payload = null;
    /**
     *  Optional Hint used to aid in search and display.
     *  Name of the inner encrypted object.
     *  @property name
     *  @type string
     */
    prototype.name = null;
    /**
     *  Array of EbacEncryptedSecret objects encoded in Base-64, encrypted using
     *  RSA public keys of owners, readers, or other parties to allow them
     *  access to the payload.
     *  @property secret
     *  @type string[]
     */
    prototype.secret = null;
    prototype.copyFrom = function(that) {
        var me = (this);
        for (var key in me)
            delete me[key];
        var you = (that);
        for (var key in you) {
            if (me[key] == null)
                me[key.replace("@", "")] = you[key];
        }
        if (!this.isAny(this.getTypes()))
             throw new RuntimeException("Incompatible type: " + this.getFullType());
    };
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacEncryptedValue.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacEncryptedValue.TYPE_0_2);
        }
        if (EbacEncryptedValue.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacEncryptedValue.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacEncryptedValue.TYPE_0_3);
        a.push(EbacEncryptedValue.TYPE_0_2);
        a.push(EbacEncryptedValue.TYPE_0_1);
        return a;
    };
}, {secret: {name: "Array", arguments: [null]}, owner: {name: "Array", arguments: [null]}, signature: {name: "Array", arguments: [null]}, reader: {name: "Array", arguments: [null]}, atProperties: {name: "Array", arguments: [null]}}, {});
/**
 *  AES encrypted public key and display name message.
 *  Used to grant access to a contact.
 *  Contains Initialization Vectors, but not secrets.
 *  Used to encrypt public identities for storage on remote systems.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacContactGrant
 *  @module org.cassproject
 */
var EbacContactGrant = function() {
    EcRemoteLinkedData.call(this, Ebac.context, EbacContactGrant.TYPE_0_3);
};
EbacContactGrant = stjs.extend(EbacContactGrant, EcRemoteLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.1/contactGrant";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/contactGrant";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/ContactGrant";
    /**
     *  Public key being granted to the owner of this message.
     *  @property pk
     *  @type string(pem)
     */
    prototype.pk = null;
    /**
     *  Display name of the contact.
     *  @property displayName
     *  @type string
     */
    prototype.displayName = null;
    /**
     *  Source server of the contact.
     *  @property source
     *  @type string
     */
    prototype.source = null;
    /**
     *  Response token used to validate that this grant is in response to a contact request you sent.
     *  @property responseToken
     *  @type string
     */
    prototype.responseToken = null;
    /**
     *  Signature (Base64 encoded) of the response token to verify against your own public key
     *  to ensure that this grant is in response to a contact request you sent.
     *  @property responseSignature
     *  @type string
     */
    prototype.responseSignature = null;
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacContactGrant.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacContactGrant.TYPE_0_2);
        }
        if (EbacContactGrant.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacContactGrant.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacContactGrant.TYPE_0_3);
        a.push(EbacContactGrant.TYPE_0_2);
        a.push(EbacContactGrant.TYPE_0_1);
        return a;
    };
}, {owner: {name: "Array", arguments: [null]}, signature: {name: "Array", arguments: [null]}, reader: {name: "Array", arguments: [null]}, atProperties: {name: "Array", arguments: [null]}}, {});
/**
 *  Message used to commit credentials to a remote login server.
 *
 *  TODO: Vulnerable to replay attacks. Token field prevents some replay
 *  attacks.
 *
 *  @author fritz.ray@eduworks.com
 *  @class EbacCredentialCommit
 *  @module org.cassproject
 */
var EbacCredentialCommit = function() {
    EcLinkedData.call(this, Ebac.context, EbacCredentialCommit.TYPE_0_3);
    this.credentials = new EbacCredentials();
};
EbacCredentialCommit = stjs.extend(EbacCredentialCommit, EcLinkedData, [], function(constructor, prototype) {
    constructor.TYPE_0_1 = "http://schema.eduworks.com/ebac/0.1/credentialCommit";
    constructor.TYPE_0_2 = "http://schema.eduworks.com/ebac/0.2/credentialCommit";
    constructor.TYPE_0_3 = "http://schema.cassproject.org/kbac/0.2/CredentialCommit";
    /**
     *  Hashed username.
     *  @property username
     *  @type string
     */
    prototype.username = null;
    /**
     *  Hashed password to authorize commit.
     *  @property password
     *  @type string
     */
    prototype.password = null;
    /**
     *  Token provided to client when previously executed Request was done. May
     *  be empty if this is used as part of Create action.
     *  @property token
     *  @type string
     */
    prototype.token = null;
    /**
     *  List of credentials to commit to the login server storage.
     *  @property credentials
     *  @type EbacCredentials
     */
    prototype.credentials = null;
    prototype.upgrade = function() {
        EcLinkedData.prototype.upgrade.call(this);
        if (EbacCredentialCommit.TYPE_0_1.equals(this.type)) {
            var me = (this);
            if (me["@context"] == null && me["@schema"] != null)
                me["@context"] = me["@schema"];
            this.setContextAndType(Ebac.context_0_2, EbacCredentialCommit.TYPE_0_2);
        }
        if (EbacCredentialCommit.TYPE_0_2.equals(this.getFullType())) {
            this.setContextAndType(Ebac.context_0_3, EbacCredentialCommit.TYPE_0_3);
        }
    };
    prototype.getTypes = function() {
        var a = new Array();
        a.push(EbacCredentialCommit.TYPE_0_3);
        a.push(EbacCredentialCommit.TYPE_0_2);
        a.push(EbacCredentialCommit.TYPE_0_1);
        return a;
    };
}, {credentials: "EbacCredentials", atProperties: {name: "Array", arguments: [null]}}, {});


text:
export function zero(x) { return Math.floor(x) }
export function one(x) { return Math.ceil(x) }
export function linear(x) { return x }
export function power_fac(exp) {
    if(exp === 1)
        return linear
    return (x) => Math.pow(x, exp)
}

export function quadratic(x) { return x * x }
export function quadraticInOut(x) {
    x *= 2
    if(x < 1)
        return x * x / 2
    x -= 1
    return -1 / 2 * (x * (x - 2) - 1)
}

export function cubic(x) { return x * x * x }
export function quartic(x) { return x * x * x * x }

export function sine(x) { return Math.sin(x * Math.PI / 2) }
export function sine_2(x) { return sine(sine(x)) }
export function sine_3(x) { return sine(sine(sine(x))) }
export function cosine(x) { return (1 - Math.cos(x * Math.PI)) / 2 }
export function circle(x) { return Math.sqrt(1 - Math.pow(x - 1, 2)) }
export function reverseSine(x) { return 1 - Math.sin((x + 1) * Math.PI / 2) }

redpajama_set_name: RedPajamaGithub


text:
package org.apache.kafka.streams.processor.internals;

import org.apache.kafka.common.header.Headers;
import org.apache.kafka.common.serialization.Deserializer;
import org.apache.kafka.streams.kstream.internals.ChangedDeserializer;
import org.apache.kafka.streams.processor.ProcessorContext;
import org.apache.kafka.streams.processor.TimestampExtractor;

import java.util.List;

public class SourceNode<K, V> extends ProcessorNode<K, V> {

    private final List<String> topics;

    private ProcessorContext context;
    private Deserializer<K> keyDeserializer;
    private Deserializer<V> valDeserializer;
    private final TimestampExtractor timestampExtractor;

    public SourceNode(final String name,
                      final List<String> topics,
                      final TimestampExtractor timestampExtractor,
                      final Deserializer<K> keyDeserializer,
                      final Deserializer<V> valDeserializer) {
        super(name);
        this.topics = topics;
        this.timestampExtractor = timestampExtractor;
        this.keyDeserializer = keyDeserializer;
        this.valDeserializer = valDeserializer;
    }

    public SourceNode(final String name,
                      final List<String> topics,
                      final Deserializer<K> keyDeserializer,
                      final Deserializer<V> valDeserializer) {
        this(name, topics, null, keyDeserializer, valDeserializer);
    }

    K deserializeKey(final String topic, final Headers headers, final byte[] data) {
        return keyDeserializer.deserialize(topic, headers, data);
    }

    V deserializeValue(final String topic, final Headers headers, final byte[] data) {
        return valDeserializer.deserialize(topic, headers, data);
    }

    @SuppressWarnings("unchecked")
    @Override
    public void init(final InternalProcessorContext context) {
        super.init(context);
        this.context = context;

        // if deserializers are null, get the default ones from the context
        if (this.keyDeserializer == null) {
            this.keyDeserializer = (Deserializer<K>) context.keySerde().deserializer();
        }
        if (this.valDeserializer == null) {
            this.valDeserializer = (Deserializer<V>) context.valueSerde().deserializer();
        }

        // if value deserializers are for {@code Change} values, set the inner deserializer when necessary
        if (this.valDeserializer instanceof ChangedDeserializer &&
                ((ChangedDeserializer) this.valDeserializer).inner() == null) {
            ((ChangedDeserializer) this.valDeserializer).setInner(context.valueSerde().deserializer());
        }
    }

    @Override
    public void process(final K key, final V value) {
        context.forward(key, value);
        sourceNodeForwardSensor().record();
    }

    /**
     * @return a string representation of this node, useful for debugging.
     */
    @Override
    public String toString() {
        return toString("");
    }

    /**
     * @return a string representation of this node starting with the given indent, useful for debugging.
     */
    public String toString(final String indent) {
        final StringBuilder sb = new StringBuilder(super.toString(indent));
        sb.append(indent).append("\ttopics:\t\t[");
        for (final String topic : topics) {
            sb.append(topic);
            sb.append(", ");
        }
        sb.setLength(sb.length() - 2);  // remove the last comma
        sb.append("]\n");
        return sb.toString();
    }

    public TimestampExtractor getTimestampExtractor() {
        return timestampExtractor;
    }
}


text:
'use strict';

angular.module('ciandtDojos.form', [])
.directive('formInput', ['$compile', function($compile) {
  return {
    templateUrl: 'form/formInput.html',
    restrict: 'E',
    scope: {
      label: "@",
      model: "=",
      inputName: "@",
      inputRequired: "@",
      inputForm: "=",
      inputPattern: "@"
    },

    controller: function($scope, $element, $attrs) {
      var input = $element.find('input');
      input.attr('name', $scope.inputName);
      if ($scope.inputRequired == 'true') {
        input.attr('required', 'required');
      }
      if($scope.inputPattern) {
        //input.attr('ng-pattern', $scope.inputPattern);
        input.attr('cpf', 'cpf');
      }
      $scope.inputForm.$addControl($compile(input)($scope));
    }

  }
}]);


text:
@interface PodsDummy_DTParallaxScrollViewController : NSObject
@end
@implementation PodsDummy_DTParallaxScrollViewController
@end


text:
<?xml version="1.0" encoding="UTF-8"?>
<objects serializationModel="Studio.01.08.00">
    <object class="AudioFile" id="{e88199c0-1dc7-47b9-afc8-7bf8dc1f4f38}">
        <property name="assetPath">
            <value>Collisions/objects/object - cardboard small/object - cardboard small 6.wav</value>
        </property>
        <property name="frequencyInKHz">
            <value>44.0999985</value>
        </property>
        <property name="channelCount">
            <value>1</value>
        </property>
        <property name="length">
            <value>0.17274376417233561</value>
        </property>
        <relationship name="masterAssetFolder">
            <destination>{df5bdea7-351b-4ee0-bbd3-53a4a8d8ac13}</destination>
        </relationship>
    </object>
</objects>


text:
/*http://chelintutorials.blogspot.com/
 *Chelin Tutorials 2011 Todos los Derechos Reservados.
 *Tut 28- Variables y metodos "Static"
 */

public class tut28 {

	public static void main(String[] args) {

		//creo algunas instancias
		claseestatica c1 = new claseestatica();
		claseestatica c2 = new claseestatica();
		claseestatica c3 = new claseestatica();

		//modifico los atributos normales
		c1.x++;
		c2.x++;
		System.out.println("x de c: "+c1.x); //podemos ver que no hay cambio

		//modifico los atributos estaticos
		c1.incrementarx();
		c2.incrementarx();
		c3.incrementarx();
		claseestatica.xcompartida++; //tambien puedo modificar sin crear una instancia

		System.out.println("x comp de c1: "+c1.xcompartida);//vemos que cambio
		System.out.println("x comp de c3: "+c3.xcompartida);
	}

}


text:
package com.codepath.apps.purplebird.fragments;

import android.os.Bundle;
import android.support.annotation.Nullable;

/**
 * Created by supsingh on 11/6/2016.
 */

public class SearchTimeLineFragment extends TweetsListFragment {

    public String getCACHE_FILE() {
        return CACHE_FILE;
    }

    public TimelineType getTimelineType_t() {
        return timelineType_t;
    }

    private final String TAG = "SearchTimeline";
    private final String CACHE_FILE = "cacheSearchTimeline.txt";
    private final TimelineType timelineType_t = TimelineType.TIMELINE_SEARCH;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    // Static
    public static SearchTimeLineFragment newInstance(String search_query) {
        SearchTimeLineFragment searchFragment = new SearchTimeLineFragment();
        Bundle args = new Bundle();
        args.putString("search_query", search_query);
        searchFragment.setArguments(args);
        return searchFragment;
    }
}


text:
package cz.seznam.euphoria.core.client.io;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * A mock factory creating a stream datasource.
 */
public class MockStreamDataSource<T>
    implements UnboundedDataSource<T, MockStreamDataSource.Offset> {

  public static final class Offset implements Serializable {
    public static Offset get() { return null; }
  }

  private final List<UnboundedPartition<T, Offset>> partitions;

  public MockStreamDataSource() {
    final int p = 4;
    this.partitions = new ArrayList<>(p);
    for (int i = 0; i < p; i++) {
      partitions.add((UnboundedPartition<T, Offset>) () -> new EmptyReader<>());
    }
  }

  @Override
  public List<UnboundedPartition<T, Offset>> getPartitions() {
    return partitions;
  }

}


text:
<?php

namespace Tests\App\Unit\Repositories\UserRepository;

use Tests\TestCase;
use Tests\DatabaseRefreshTable;
use App\Dumps\UserDump;
use App\Dumps\DumpsFactories\DumpFactory;
use App\Services\Player;
use App\Repositories\UserRepository\Collection\UserCollection;
use App\Exceptions\UserNotAllowedException;

class UserCollectionTest extends TestCase
{
    use DatabaseRefreshTable;

    /**
     * @var UserDump
     */
    private $userDump;

    /**
     * @var DumpFactory
     */
    private $dumpFactory;

    /**
     * @var UserCollection
     */
    private $userCollection;

    public function setUp()
    {
        parent::setUp();

        $this->userDump = $this->container->get(UserDump::class);
        $this->dumpFactory = $this->container->get('DumpFactory');
        $this->userCollection = $this->container->get(UserCollection::class);
    }

    public function testMustRetrieveAllUsersForMasterUser()
    {
        $user = $this->userDump->create(['type' => 'M']);
        $this->dumpFactory->produce($this->userDump, 5);

        Player::setPlayer($user);

        $this->assertCount(5, $this->userCollection->getAll());
    }

    public function testMustThrownExceptionForNoMasterUser()
    {
        $user = $this->userDump->create();

        Player::setPlayer($user);

        $this->expectException(UserNotAllowedException::class);

        $this->userCollection->getAll();
    }
}


text:
/*global ko, Router */
(function () {
    'use strict';

    var ENTER_KEY = 13;
    var ESCAPE_KEY = 27;

// A factory function we can use to create binding handlers for specific
// keycodes.
    function keyhandlerBindingFactory(keyCode) {
        return {
            init: function (element, valueAccessor, allBindingsAccessor, data, bindingContext) {
                var wrappedHandler, newValueAccessor;

// wrap the handler with a check for the enter key
                wrappedHandler = function (data, event) {
                    if (event.keyCode === keyCode) {
                        valueAccessor().call(this, data, event);
                    }
                };

// create a valueAccessor with the options that we would want to pass to the event binding
                newValueAccessor = function () {
                    return {
                        keyup: wrappedHandler
                    };
                };

// call the real event binding's init function
                ko.bindingHandlers.event.init(element, newValueAccessor, allBindingsAccessor, data, bindingContext);
            }
        };
    }

// a custom binding to handle the enter key
    ko.bindingHandlers.enterKey = keyhandlerBindingFactory(ENTER_KEY);

// another custom binding, this time to handle the escape key
    ko.bindingHandlers.escapeKey = keyhandlerBindingFactory(ESCAPE_KEY);

// wrapper to hasFocus that also selects text and applies focus async
    ko.bindingHandlers.selectAndFocus = {
        init: function (element, valueAccessor, allBindingsAccessor, bindingContext) {
            ko.bindingHandlers.hasFocus.init(element, valueAccessor, allBindingsAccessor, bindingContext);
            ko.utils.registerEventHandler(element, 'focus', function () {
                element.focus();
            });
        },
        update: function (element, valueAccessor) {
            ko.utils.unwrapObservable(valueAccessor()); // for dependency
// ensure that element is visible before trying to focus
            setTimeout(function () {
                ko.bindingHandlers.hasFocus.update(element, valueAccessor);
            }, 0);
        }
    };

// represent a single todo item
    var Todo = function (title, completed) {
        this.title = ko.observable(title);
        this.completed = ko.observable(completed);
        this.editing = ko.observable(false);
    };

// our main view model
    var ViewModel = function (todos) {
// map array of passed in todos to an observableArray of Todo objects
        this.todos = ko.observableArray(todos.map(function (todo) {
            return new Todo(todo.title, todo.completed);
        }));

// store the new todo value being entered
        this.current = ko.observable();

        this.showMode = ko.observable('all');

        this.filteredTodos = ko.computed(function () {
            switch (this.showMode()) {
                case 'active':
                    return this.todos().filter(function (todo) {
                        return !todo.completed();
                    });
                case 'completed':
                    return this.todos().filter(function (todo) {
                        return todo.completed();
                    });
                default:
                    return this.todos();
            }
        }.bind(this));

// add a new todo, when enter key is pressed
        this.add = function () {
            var current = this.current().trim();
            if (current) {
                this.todos.push(new Todo(current));
                this.current('');
            }
        }.bind(this);

// remove a single todo
        this.remove = function (todo) {
            this.todos.remove(todo);
        }.bind(this);

// remove all completed todos
        this.removeCompleted = function () {
            this.todos.remove(function (todo) {
                return todo.completed();
            });
        }.bind(this);

// edit an item
        this.editItem = function (item) {
            item.editing(true);
            item.previousTitle = item.title();
        }.bind(this);

// stop editing an item. Remove the item, if it is now empty
        this.saveEditing = function (item) {
            item.editing(false);

            var title = item.title();
            var trimmedTitle = title.trim();

// Observable value changes are not triggered if they're consisting of whitespaces only
// Therefore we've to compare untrimmed version with a trimmed one to chech whether anything changed
// And if yes, we've to set the new value manually
            if (title !== trimmedTitle) {
                item.title(trimmedTitle);
            }

            if (!trimmedTitle) {
                this.remove(item);
            }
        }.bind(this);

// cancel editing an item and revert to the previous content
        this.cancelEditing = function (item) {
            item.editing(false);
            item.title(item.previousTitle);
        }.bind(this);

// count of all completed todos
        this.completedCount = ko.computed(function () {
            return this.todos().filter(function (todo) {
                return todo.completed();
            }).length;
        }.bind(this));

// count of todos that are not complete
        this.remainingCount = ko.computed(function () {
            return this.todos().length - this.completedCount();
        }.bind(this));

// writeable computed observable to handle marking all complete/incomplete
        this.allCompleted = ko.computed({
//always return true/false based on the done flag of all todos
            read: function () {
                return !this.remainingCount();
            }.bind(this),
// set all todos to the written value (true/false)
            write: function (newValue) {
                this.todos().forEach(function (todo) {
// set even if value is the same, as subscribers are not notified in that case
                    todo.completed(newValue);
                });
            }.bind(this)
        });

// helper function to keep expressions out of markup
        this.getLabel = function (count) {
            return ko.utils.unwrapObservable(count) === 1 ? 'item' : 'items';
        }.bind(this);

// internal computed observable that fires whenever anything changes in our todos
        ko.computed(function () {
// store a clean copy to local storage, which also creates a dependency on the observableArray and all observables in each item
                localStorage.setItem('todos-knockoutjs', ko.toJSON(this.todos));
            }.bind(this)).extend({
                rateLimit: { timeout: 500, method: 'notifyWhenChangesStop' }
            }); // save at most twice per second
    };

// check local storage for todos
    var todos = ko.utils.parseJson(localStorage.getItem('todos-knockoutjs'));

// bind a new instance of our view model to the page
    var viewModel = new ViewModel(todos || []);
    ko.applyBindings(viewModel);

// set up filter routing
    /*jshint newcap:false */
    Router({ '/:filter': viewModel.showMode }).init();
}());


text:
from abc import ABCMeta, abstractmethod
from frappe.utils.password import get_decrypted_password

class BaseConnection(metaclass=ABCMeta):
	@abstractmethod
	def get(self, remote_objectname, fields=None, filters=None, start=0, page_length=10):
		pass

	@abstractmethod
	def insert(self, doctype, doc):
		pass

	@abstractmethod
	def update(self, doctype, doc, migration_id):
		pass

	@abstractmethod
	def delete(self, doctype, migration_id):
		pass

	def get_password(self):
		return get_decrypted_password('Data Migration Connector', self.connector.name)


text:
class Settings4 < Settingslogic
  source "#{File.dirname(__FILE__)}/settings.yml"
  default_namespace 'default_settings4'
  namespace 'language'
end


text:
<?php

namespace PHPixie\Validate\Values;

use PHPixie\Validate\Errors;
use PHPixie\Validate\Values;

/**
 * Class Result
 * @package PHPixie\Validate\Values
 */
class Result
{
    /**
     * @var Values
     */
    protected $values;
    /**
     * @var Errors
     */
    protected $errorBuilder;

    /**
     * @var array
     */
    protected $errors       = array();
    /**
     * @var array
     */
    protected $fieldResults = array();

    /**
     * Result constructor.
     * @param $values Values
     * @param $errorBuilder Errors
     */
    public function __construct($values, $errorBuilder)
    {
        $this->values       = $values;
        $this->errorBuilder = $errorBuilder;
    }

    /**
     * @return array
     */
    public function errors()
    {
        return $this->errors;
    }

    /**
     * @return array
     */
    public function fieldResults()
    {
        return $this->fieldResults;
    }

    /**
     * @param $name string
     * @return Result
     */
    public function field($name)
    {
        if(!array_key_exists($name, $this->fieldResults)) {
            $this->fieldResults[$name] = $this->values->result();
        }

        return $this->fieldResults[$name];
    }

    /**
     * @param $name string
     * @param $result Result
     */
    public function setFieldResult($name, $result)
    {
        $this->fieldResults[$name] = $result;
    }

    /**
     * @return array
     */
    public function invalidFieldResults()
    {
        $invalidResults = array();

        foreach($this->fieldResults() as $field => $result) {
            if(!$result->isValid()) {
                $invalidResults[$field] = $result;
            }
        }

        return $invalidResults;
    }

    /**
     * @return bool
     */
    public function isValid()
    {
        if(!empty($this->errors)) {
            return false;
        }

        return count($this->invalidFieldResults()) === 0;
    }

    /**
     * @return Result
     */
    public function addEmptyValueError()
    {
        return $this->addError(
            $this->errorBuilder->emptyValue()
        );
    }

    /**
     * @param $filterName string
     * @return Result
     */
    public function addFilterError($filterName)
    {
        return $this->addError(
            $this->errorBuilder->filter($filterName)
        );
    }

    /**
     * @param $message string
     * @return Result
     */
    public function addMessageError($message)
    {
        return $this->addError(
            $this->errorBuilder->message($message)
        );
    }

    /**
     * @param $customType string
     * @param null|string $stringValue
     * @return Result
     */
    public function addCustomError($customType, $stringValue = null)
    {
        return $this->addError(
            $this->errorBuilder->custom($customType, $stringValue)
        );
    }

    /**
     * @return Result
     */
    public function addArrayTypeError()
    {
        return $this->addError(
            $this->errorBuilder->arrayType()
        );
    }

    /**
     * @return Result
     */
    public function addScalarTypeError()
    {
        return $this->addError(
            $this->errorBuilder->scalarType()
        );
    }

    /**
     * @param $error Errors\Error\ValueType\Scalar
     * @return $this
     */
    public function addError($error)
    {
        $this->errors[]= $error;
        return $this;
    }

    /**
     * @param $extraKeys
     */
    public function addIvalidKeysError($extraKeys){}

    /**
     * @param $a
     * @param $b
     * @param $c
     */
    public function addArrayCountError($a,$b,$c){}
}


text:
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>

#include <linux/debugfs.h>
#include <linux/seq_file.h>

#include <asm/opal.h>

/*
 * This driver creates the a Linux MTD abstraction for platform PNOR flash
 * backed by OPAL calls
 */

struct powernv_flash {
	struct mtd_info	mtd;
	u32 id;
};

enum flash_op {
	FLASH_OP_READ,
	FLASH_OP_WRITE,
	FLASH_OP_ERASE,
};

static int powernv_flash_async_op(struct mtd_info *mtd, enum flash_op op,
		loff_t offset, size_t len, size_t *retlen, u_char *buf)
{
	struct powernv_flash *info = (struct powernv_flash *)mtd->priv;
	struct device *dev = &mtd->dev;
	int token;
	struct opal_msg msg;
	int rc;

	dev_dbg(dev, "%s(op=%d, offset=0x%llx, len=%zu)\n",
			__func__, op, offset, len);

	token = opal_async_get_token_interruptible();
	if (token < 0) {
		if (token != -ERESTARTSYS)
			dev_err(dev, "Failed to get an async token\n");

		return token;
	}

	switch (op) {
	case FLASH_OP_READ:
		rc = opal_flash_read(info->id, offset, __pa(buf), len, token);
		break;
	case FLASH_OP_WRITE:
		rc = opal_flash_write(info->id, offset, __pa(buf), len, token);
		break;
	case FLASH_OP_ERASE:
		rc = opal_flash_erase(info->id, offset, len, token);
		break;
	default:
		BUG_ON(1);
	}

	if (rc != OPAL_ASYNC_COMPLETION) {
		dev_err(dev, "opal_flash_async_op(op=%d) failed (rc %d)\n",
				op, rc);
		opal_async_release_token(token);
		return -EIO;
	}

	rc = opal_async_wait_response(token, &msg);
	opal_async_release_token(token);
	if (rc) {
		dev_err(dev, "opal async wait failed (rc %d)\n", rc);
		return -EIO;
	}

	rc = be64_to_cpu(msg.params[1]);
	if (rc == OPAL_SUCCESS) {
		rc = 0;
		if (retlen)
			*retlen = len;
	} else {
		rc = -EIO;
	}

	return rc;
}

/**
 * @mtd: the device
 * @from: the offset to read from
 * @len: the number of bytes to read
 * @retlen: the number of bytes actually read
 * @buf: the filled in buffer
 *
 * Returns 0 if read successful, or -ERRNO if an error occurred
 */
static int powernv_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
	     size_t *retlen, u_char *buf)
{
	return powernv_flash_async_op(mtd, FLASH_OP_READ, from,
			len, retlen, buf);
}

/**
 * @mtd: the device
 * @to: the offset to write to
 * @len: the number of bytes to write
 * @retlen: the number of bytes actually written
 * @buf: the buffer to get bytes from
 *
 * Returns 0 if write successful, -ERRNO if error occurred
 */
static int powernv_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
		     size_t *retlen, const u_char *buf)
{
	return powernv_flash_async_op(mtd, FLASH_OP_WRITE, to,
			len, retlen, (u_char *)buf);
}

/**
 * @mtd: the device
 * @erase: the erase info
 * Returns 0 if erase successful or -ERRNO if an error occurred
 */
static int powernv_flash_erase(struct mtd_info *mtd, struct erase_info *erase)
{
	int rc;

	erase->state = MTD_ERASING;

	/* todo: register our own notifier to do a true async implementation */
	rc =  powernv_flash_async_op(mtd, FLASH_OP_ERASE, erase->addr,
			erase->len, NULL, NULL);

	if (rc) {
		erase->fail_addr = erase->addr;
		erase->state = MTD_ERASE_FAILED;
	} else {
		erase->state = MTD_ERASE_DONE;
	}
	mtd_erase_callback(erase);
	return rc;
}

/**
 * powernv_flash_set_driver_info - Fill the mtd_info structure and docg3
 * structure @pdev: The platform device
 * @mtd: The structure to fill
 */
static int powernv_flash_set_driver_info(struct device *dev,
		struct mtd_info *mtd)
{
	u64 size;
	u32 erase_size;
	int rc;

	rc = of_property_read_u32(dev->of_node, "ibm,flash-block-size",
			&erase_size);
	if (rc) {
		dev_err(dev, "couldn't get resource block size information\n");
		return rc;
	}

	rc = of_property_read_u64(dev->of_node, "reg", &size);
	if (rc) {
		dev_err(dev, "couldn't get resource size information\n");
		return rc;
	}

	/*
	 * Going to have to check what details I need to set and how to
	 * get them
	 */
	mtd->name = of_get_property(dev->of_node, "name", NULL);
	mtd->type = MTD_NORFLASH;
	mtd->flags = MTD_WRITEABLE;
	mtd->size = size;
	mtd->erasesize = erase_size;
	mtd->writebufsize = mtd->writesize = 1;
	mtd->owner = THIS_MODULE;
	mtd->_erase = powernv_flash_erase;
	mtd->_read = powernv_flash_read;
	mtd->_write = powernv_flash_write;
	mtd->dev.parent = dev;
	return 0;
}

/**
 * powernv_flash_probe
 * @pdev: platform device
 *
 * Returns 0 on success, -ENOMEM, -ENXIO on error
 */
static int powernv_flash_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct powernv_flash *data;
	int ret;

	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
	if (!data) {
		ret = -ENOMEM;
		goto out;
	}
	data->mtd.priv = data;

	ret = of_property_read_u32(dev->of_node, "ibm,opal-id", &(data->id));
	if (ret) {
		dev_err(dev, "no device property 'ibm,opal-id'\n");
		goto out;
	}

	ret = powernv_flash_set_driver_info(dev, &data->mtd);
	if (ret)
		goto out;

	dev_set_drvdata(dev, data);

	/*
	 * The current flash that skiboot exposes is one contiguous flash chip
	 * with an ffs partition at the start, it should prove easier for users
	 * to deal with partitions or not as they see fit
	 */
	ret = mtd_device_register(&data->mtd, NULL, 0);

out:
	return ret;
}

/**
 * op_release - Release the driver
 * @pdev: the platform device
 *
 * Returns 0
 */
static int powernv_flash_release(struct platform_device *pdev)
{
	struct powernv_flash *data = dev_get_drvdata(&(pdev->dev));

	/* All resources should be freed automatically */
	return mtd_device_unregister(&(data->mtd));
}

static const struct of_device_id powernv_flash_match[] = {
	{ .compatible = "ibm,opal-flash" },
	{}
};

static struct platform_driver powernv_flash_driver = {
	.driver		= {
		.name		= "powernv_flash",
		.of_match_table	= powernv_flash_match,
	},
	.remove		= powernv_flash_release,
	.probe		= powernv_flash_probe,
};

module_platform_driver(powernv_flash_driver);

MODULE_DEVICE_TABLE(of, powernv_flash_match);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Cyril Bur <cyril.bur@au1.ibm.com>");
MODULE_DESCRIPTION("MTD abstraction for OPAL flash");


text:
O código-fonte do Electron é separado em algumas partes, seguindo principalmente as convenções de separação do chromium.

Você pode se familiarizar com a [arquitetura de multiprocessamento ](http://dev.chromium.org/developers/design-documents/multi-process-architecture) do Chromium para entender melhor o código-fonte.

## Estrutura do Código-Fonte

```
Electron
├──atom - Código fonte do Electron.
|  ├── app - Código de inicialização.
|  ├── browser - A interface incluíndo a janela principal, UI, e todas as coisas do processo principal. Ele se comunica com o renderizador para gerenciar as páginas web.
|  |   ├── lib -  Código Javascript para inicializar o processo principal.
|  |   ├── ui - Implementação da UI para plataformas distintas.
|  |   |   ├── cocoa - Código-fonte específico do cocoa .
|  |   |   ├── gtk - Código-font específico do GTK+.
|  |   |   └── win - Código-fonte específico do Windows GUI.
|  |   ├── default_app - A página padrão é mostrada quando
|  |   |   Electron inicializa sem fornecer um app.
|  |   ├── api - Implementação do processo principal das APIs
|  |   |   └── lib - Código Javascript, parte da implementação da API.
|  |   ├── net - Código relacionado a rede.
|  |   ├── mac - Código fonte em Object-c, específico para Mac.
|  |   └── resources - Icones, arquivos dependentes da plataforma, etc.
|  ├── renderer - Código que é executado no processo de renderização.
|  |   ├── lib -  Parte do código Javascript  de inicialização do renderizador.
|  |   └── api - Implementação das APIs para o processo de renderizaçãp.
|  |       └── lib - Código Javascript, parte da implementação da API.
|  └── common - Código que utiliza ambos os processos, o principal e o de rendezição,
|      ele inclui algumas funções utilitárias e códigos para integrar com ciclo de mensagens do node no ciclo de mensagens do Chromium.
|      ├── lib - Código Javascript comum para a inicialização.
|      └── api - A implementação de APIs comuns e fundamentação dos
|          módulos integrados com Electron's.
|          └── lib - Código Javascript, parte da implementação da API.
├── chromium_src - Código-fonte copiado do Chromium.
├── docs - Documentação.
├── spec - Testes Automáticos.
├── atom.gyp - Regras de compilação do Electron.
└── common.gypi - Configuração específica do compilador e regras de construção para outros componentes
    como `node` e `breakpad`.
```

## Estrutura de Outros Diretórios.

* **script** - Scripts utilizado para fins de desenvolvimento como building, packaging, testes, etc.
* **tools** - Scripts auxiliares, utilizados pelos arquivos gyp, ao contrário do`script`, os scripts colocados aqui nunca devem ser invocados diretamente pelos usuários.
* **vendor** - Dependências de código-fonte de terceiros, nós não utilizamos  `third_party` como nome porque ele poderia ser confundido com o diretório homônimo existente no código-fonte do Chromium.
* **node_modules** - Módulos de terceiros em node usados para compilação
* **out** - Diretório temporário saída do `ninja`.
* **dist** - Diretório temporário do `script/create-dist.py` ao criar uma distribuição
* **external_binaries** - Binários baixados de Frameworks de terceiros que não suportam a compilação com `gyp`.


text:
FROM ubuntu:16.04
LABEL Olivier Bonnaure <olivier@solisoft.net>

# install build dependencies
RUN apt-get -qq update && apt-get -qqy install libreadline-dev libncurses5-dev libpcre3-dev libssl-dev perl make curl git-core luarocks

# build/install OpenResty
ENV SRC_DIR /opt
ENV OPENRESTY_VERSION 1.13.6.1
ENV OPENRESTY_PREFIX /opt/openresty
ENV LAPIS_VERSION 1.7.0

RUN cd $SRC_DIR && curl -LOs https://openresty.org/download/openresty-$OPENRESTY_VERSION.tar.gz \
 && tar xzf openresty-$OPENRESTY_VERSION.tar.gz && cd openresty-$OPENRESTY_VERSION \
 && ./configure --prefix=$OPENRESTY_PREFIX \
 --with-luajit \
 --with-http_realip_module \
 --with-http_stub_status_module \
 && make && make install && rm -rf openresty-$OPENRESTY_VERSION*

RUN luarocks install --server=http://rocks.moonscript.org/manifests/leafo lapis $LAPIS_VERSION
RUN luarocks install moonscript
RUN luarocks install lapis-console
RUN luarocks install lustache
RUN luarocks install stringy

WORKDIR /var/www

ENV LAPIS_OPENRESTY $OPENRESTY_PREFIX/nginx/sbin/nginx

# Setup sample lapis project.
# RUN mv nginx.conf nginx.conf.bk && lapis new && moonc *.moon

# LAPIS_OPENRESTY=/opt/openresty/nginx/sbin/nginx lapis server production

# ENTRYPOINT lapis server && /bin/bash
# ENTRYPOINT ["lapis"]


text:
package rest

import (
	authorizationv1 "k8s.io/api/authorization/v1"
	authorizationv1beta1 "k8s.io/api/authorization/v1beta1"
	"k8s.io/apiserver/pkg/authorization/authorizer"
	"k8s.io/apiserver/pkg/registry/generic"
	"k8s.io/apiserver/pkg/registry/rest"
	genericapiserver "k8s.io/apiserver/pkg/server"
	serverstorage "k8s.io/apiserver/pkg/server/storage"
	"k8s.io/kubernetes/pkg/api/legacyscheme"
	"k8s.io/kubernetes/pkg/apis/authorization"
	"k8s.io/kubernetes/pkg/registry/authorization/localsubjectaccessreview"
	"k8s.io/kubernetes/pkg/registry/authorization/selfsubjectaccessreview"
	"k8s.io/kubernetes/pkg/registry/authorization/selfsubjectrulesreview"
	"k8s.io/kubernetes/pkg/registry/authorization/subjectaccessreview"
)

type RESTStorageProvider struct {
	Authorizer   authorizer.Authorizer
	RuleResolver authorizer.RuleResolver
}

func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool) {
	if p.Authorizer == nil {
		return genericapiserver.APIGroupInfo{}, false
	}

	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(authorization.GroupName, legacyscheme.Registry, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs)
	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
	// TODO refactor the plumbing to provide the information in the APIGroupInfo

	if apiResourceConfigSource.VersionEnabled(authorizationv1beta1.SchemeGroupVersion) {
		apiGroupInfo.VersionedResourcesStorageMap[authorizationv1beta1.SchemeGroupVersion.Version] = p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter)
		apiGroupInfo.GroupMeta.GroupVersion = authorizationv1beta1.SchemeGroupVersion
	}

	if apiResourceConfigSource.VersionEnabled(authorizationv1.SchemeGroupVersion) {
		apiGroupInfo.VersionedResourcesStorageMap[authorizationv1.SchemeGroupVersion.Version] = p.v1Storage(apiResourceConfigSource, restOptionsGetter)
		apiGroupInfo.GroupMeta.GroupVersion = authorizationv1.SchemeGroupVersion
	}

	return apiGroupInfo, true
}

func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) map[string]rest.Storage {
	storage := map[string]rest.Storage{}
	// subjectaccessreviews
	storage["subjectaccessreviews"] = subjectaccessreview.NewREST(p.Authorizer)
	// selfsubjectaccessreviews
	storage["selfsubjectaccessreviews"] = selfsubjectaccessreview.NewREST(p.Authorizer)
	// localsubjectaccessreviews
	storage["localsubjectaccessreviews"] = localsubjectaccessreview.NewREST(p.Authorizer)
	// selfsubjectrulesreviews
	storage["selfsubjectrulesreviews"] = selfsubjectrulesreview.NewREST(p.RuleResolver)

	return storage
}

func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) map[string]rest.Storage {
	storage := map[string]rest.Storage{}
	// subjectaccessreviews
	storage["subjectaccessreviews"] = subjectaccessreview.NewREST(p.Authorizer)
	// selfsubjectaccessreviews
	storage["selfsubjectaccessreviews"] = selfsubjectaccessreview.NewREST(p.Authorizer)
	// localsubjectaccessreviews
	storage["localsubjectaccessreviews"] = localsubjectaccessreview.NewREST(p.Authorizer)
	// selfsubjectrulesreviews
	storage["selfsubjectrulesreviews"] = selfsubjectrulesreview.NewREST(p.RuleResolver)

	return storage
}

func (p RESTStorageProvider) GroupName() string {
	return authorization.GroupName
}


text:
    <meta http-equiv="Content-Type" content="text/html; charset=Windows-1252" />
    <meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5" />
    <title>AbstractField.GetOmitNorms Method</title>
    <xml>
    </xml>
    <link rel="stylesheet" type="text/css" href="MSDN.css" />

            Apache Lucene.Net 2.4.0 Class Library API

AbstractField.GetOmitNorms Method

True if norms are omitted for this indexed field

public virtual bool GetOmitNorms();

Implements

        Fieldable.GetOmitNorms

See Also

        AbstractField Class | Lucene.Net.Documents Namespace

      <object type="application/x-oleobject" classid="clsid:1e2a7bd0-dab9-11d0-b93a-00c04fc99f9e" viewastext="true" style="display: none;">
        <param name="Keyword" value="GetOmitNorms method">
        </param>
        <param name="Keyword" value="GetOmitNorms method, AbstractField class">
        </param>
        <param name="Keyword" value="AbstractField.GetOmitNorms method">
        </param>
      </object>

Generated from assembly Lucene.Net [2.4.0.2]


text:
$pkg_name="broken_after_failure_plan"
$pkg_origin="habitat-testing"
$pkg_maintainer="The Habitat Maintainers <humans@habitat.sh>"
$pkg_version="0.0.0"

function Invoke-Build {
    throw "build is broken"
}

function Invoke-AfterSuccess {
    throw "I am a success"
}

function Invoke-AfterFailure {
    throw "failure after failure"
}


text:
<?php
	global $post;

	$biglayout = true;

	$thumb = '';
	$width = $biglayout ? 466 : 222;
	$height = 180;
	$classtext = '';
	$titletext = get_the_title();

	$thumbnail = GlobalTechDev::singleton()->get_thumb($width, $height);
	$thumb = $thumbnail["thumb"]; ?>

<div class="entry <?php if ($biglayout) echo('big'); else echo('small');?>">

		<a href="<?php the_permalink(); ?>">
			<?php print_thumbnail($thumb, $thumbnail["use_timthumb"], $titletext, $width, $height, $classtext); ?>

<a href="<?php the_permalink(); ?>"><?php if ($biglayout) truncate_title(50); else truncate_title(20); ?>

Project

<?php if ($biglayout) truncate_post(650); else truncate_post(295); ?>

					<a href="<?php the_permalink(); ?>" class="readmore">»»


text:
package pro.taskana.workbasket.api;

import pro.taskana.common.api.QueryColumnName;

/**
 * Enum containing the column names for {@link
 * pro.taskana.workbasket.internal.WorkbasketQueryMapper#queryWorkbasketAccessItemColumnValues}.
 */
public enum AccessItemQueryColumnName implements QueryColumnName {
  ID("id"),
  WORKBASKET_ID("workbasket_id"),
  WORKBASKET_KEY("wb.key"),
  ACCESS_ID("access_id");

  private String name;

  AccessItemQueryColumnName(String name) {
    this.name = name;
  }

  @Override
  public String toString() {
    return name;
  }
}