text:
package fr.netixx.AutoTopo.statistics;

import au.com.bytecode.opencsv.CSVWriter;
import fr.netixx.AutoTopo.agents.IScope;
import fr.netixx.AutoTopo.agents.Scope;

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

public class TimeScope extends AbstractStatistic {

    private static boolean enabled = true;
    private static final String[] headers = new String[]{"scope", "create", "delete", "avg","std", "min", "max"};
    private SortedMap<IScope, ConnectionsRecorder> connectionMap = new TreeMap<>();

    private RecordFilter<IScope> filter = null;

    public TimeScope(String name) {
        super(name, headers);
    }

    public TimeScope(String name, RecordFilter<IScope> filter) {
        super(name, headers);
        this.filter = filter;
    }

    public void record(Double time, IScope el) {
        if (enabled) {
            if (filter != null && filter.filter(el))
                return;
            if (!connectionMap.containsKey(el)) {
                connectionMap.put(el, new ConnectionsRecorder(1, time));
            } else {
                connectionMap.get(el).recordConnectionNumber(1, time);
            }
        }

        // el.getConnectionManager().getConnectedChildren().size();
    }

    @Override
    public void toCsv(Path csv) {
        OpenOption[] opts = new OpenOption[]{
                // StandardOpenOption .WRITE, StandardOpenOption.CREATE
        };
        try (BufferedWriter writer = Files.newBufferedWriter(csv, Charset.forName("UTF-8"), opts)) {
            CSVWriter csvW = new CSVWriter(writer, ';');

            csvW.writeNext(this.getHeader());
            for (Map.Entry<IScope, ConnectionsRecorder> entry : connectionMap.entrySet()) {
                csvW.writeNext(new String[]{"" + entry.getKey().getId(),
                        "" + entry.getValue().createTime,
                        "" + entry.getValue().destroyTime,
                        "" + entry.getValue().getAvg(),
                        "" + entry.getValue().getStd(),
                        "" + entry.getValue().getMin(),
                        "" + entry.getValue().getMax()});
            }
            csvW.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private class ConnectionsRecorder {
        double createTime;
        double destroyTime;

        double currentTime;
        int curConn;

        int n = 0;
        int max = 0;
        int min = 0;
        double m = 0;
        double s = 0;

        ConnectionsRecorder(int nConnections, double time) {
            this.createTime = time;
            currentTime = time;
            curConn = nConnections;
            n = nConnections;
            max = nConnections;
            min = nConnections;
            recordConnectionNumber(nConnections, time);
        }

        void recordConnectionNumber(int nConnections, double time) {
            destroyTime = time;
            if (time > currentTime) {
                //start new
                max = Math.max(curConn, max);
                min = Math.min(curConn, min);
                double tmpM = m;
                m += (curConn - tmpM) / n;
                s += (curConn - tmpM) * (curConn - m);
                n++;
                curConn = nConnections;
                currentTime = time;
            } else {
                curConn += nConnections;
            }
        }

        double getAvg() {
            return m;
        }

        double getVariance() {
            return s / (n - 1);
        }

        double getStd() {
            return Math.sqrt(getVariance());
        }

        int getMax() {
            return max;
        }

        int getMin() {
            return min;
        }

    }
}

redpajama_set_name: RedPajamaGithub


text:
package regex

import (
	"regexp"
	"strconv"

	log "github.com/cihub/seelog"
)

// IsClusterName validates a cluster name against the cluster name regex
func IsClusterName(clusterName string) bool {
	validClusterName := regexp.MustCompile(ClusterNameRegex)
	if validClusterName.MatchString(clusterName) {
		return true
	}
	return false
}

// IsClusterARN validates a cluster ARN against the cluster ARN regex
func IsClusterARN(clusterARN string) bool {
	validClusterARN := regexp.MustCompile(ClusterARNRegex)
	if validClusterARN.MatchString(clusterARN) {
		return true
	}
	return false
}

// IsTaskARN validates a task ARN against the task ARN regex
func IsTaskARN(taskARN string) bool {
	validTaskARN := regexp.MustCompile(TaskARNRegex)
	if validTaskARN.MatchString(taskARN) {
		return true
	}
	return false
}

// IsInstanceARN validates an instance ARN against the instance ARN regex
func IsInstanceARN(instanceARN string) bool {
	validInstanceARN := regexp.MustCompile(InstanceARNRegex)
	if validInstanceARN.MatchString(instanceARN) {
		return true
	}
	return false
}

// IsEntityVersion validates an entity version as a positive integer
func IsEntityVersion(entityVersion string) bool {
	value, err := strconv.ParseInt(entityVersion, 10, 64)
	if err != nil {
		log.Warnf("Error parsing entity version: %v", err)
		return false
	}

	if value >= 0 {
		return true
	}
	return false
}


text:
package org.wso2.emm.agent.proxy.authenticators;

import org.wso2.emm.agent.proxy.IdentityProxy;
import org.wso2.emm.agent.proxy.interfaces.AuthenticationCallback;

/**
 * Creates new instances of authenticators based on the pre-configured authenticators.
 */
public class AuthenticatorFactory {
    public ClientAuthenticator getClient(String authenticatorType, AuthenticationCallback callback,
                                         int requestCode) {
        if (authenticatorType == null) {
            return null;
        }
        if (authenticatorType.equalsIgnoreCase("MUTUAL_SSL_AUTHENTICATOR")) {
            return new MutualSSLAuthenticator(IdentityProxy.getInstance().getContext(), callback,
                                              requestCode);
        } else if (authenticatorType.equalsIgnoreCase("OAUTH_AUTHENTICATOR")) {
            return new OAuthAuthenticator();
        }

        return null;
    }
}


text:
namespace sharp.Serene.Administration {
    export interface UserRoleUpdateRequest extends Serenity.ServiceRequest {
        UserID?: number;
        Roles?: number[];
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android"
    android:shareInterpolator="false">

    <alpha
        android:duration="@android:integer/config_mediumAnimTime"
        android:fromAlpha="1.0"
        android:toAlpha="0.0" />
</set>


text:
var https = require("https");

var URLShortener = module.exports = function(bot) {
    bot.register_command('s', this.shorten);
    bot.register_command('shorturl', 's');
};

URLShortener.prototype.shorten = function(context, text) {
    context.bot.shorten_url(text, function(shortUrl) {
        context.bot.send_message(context.channel, shortUrl, context.intent);
    });
};


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.6"/>
<title>Boost.Geometry.Index: Class Index</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="search/search.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />

Boost.Geometry.Index

Main Page

Modules

Classes

Files

          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)"
               onblur="searchBox.OnSearchFieldFocus(false)"
               onkeyup="searchBox.OnSearchFieldChange(event)"/>

Class List

Class Index

Class Hierarchy

Class Members

 All Classes Functions Typedefs Groups

Class Index

D | E | I | L | Q | R

  d

	equal_to (boost::geometry::index)   	indexable (boost::geometry::index)

  q

	rtree (boost::geometry::index)

equal_to< boost::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >, false > (boost::geometry::index::detail)   	indexable< boost::tuple< Indexable, T1, T2, T3, T4, T5, T6, T7, T8, T9 >, false > (boost::geometry::index::detail)

dynamic_linear (boost::geometry::index)   	equal_to< std::pair< T1, T2 >, false > (boost::geometry::index::detail)   	indexable< std::pair< Indexable, T2 >, false > (boost::geometry::index::detail)   	quadratic (boost::geometry::index)

dynamic_quadratic (boost::geometry::index)   	equal_to< std::tuple< Args...>, false > (boost::geometry::index::detail)   	indexable< std::tuple< Indexable, Args...>, false > (boost::geometry::index::detail)

  r

dynamic_rstar (boost::geometry::index)

  i

  l

  e

	rstar (boost::geometry::index)

indexable (boost::geometry::index::detail)   	linear (boost::geometry::index)

equal_to (boost::geometry::index::detail)

D | E | I | L | Q | R

<address class="footer">
Generated on Thu Dec 22 2016 12:40:17 for Boost.Geometry.Index by

 1.8.6
</address>


text:
package org.abhijitsarkar.feign.api.domain

/**
  * @author Abhijit Sarkar
  */

object RetryStrategy extends Enumeration {
  val Always = Value("ALWAYS")
  val OnFailure = Value("ON_FAILURE")
}

case class Retry(maxRetryCount: Option[Int] = None, retryStrategy: Option[String] = None)


text:
export * from './color-input.component';
export * from './color-picker.component';
export * from './color-picker.module';
export * from './color-swatch.component';


text:
\n
static bool ir_pre_enabled(struct intel_iommu *iommu)
static void clear_ir_pre_enabled(struct intel_iommu *iommu)
static void init_ir_status(struct intel_iommu *iommu)
static int alloc_irte(struct intel_iommu *iommu, int irq, struct irq_2_iommu *irq_iommu, u16 count)
static int qi_flush_iec(struct intel_iommu *iommu, int index, int mask)
static int modify_irte(struct irq_2_iommu *irq_iommu, struct irte *irte_modified)
static struct intel_iommu *map_hpet_to_ir(u8 hpet_id)
static struct intel_iommu *map_ioapic_to_ir(int apic)
static struct intel_iommu *map_dev_to_ir(struct pci_dev *dev)
static int clear_entries(struct irq_2_iommu *irq_iommu)
static void set_irte_sid(struct irte *irte, unsigned int svt, unsigned int sq, unsigned int sid)
static int set_ioapic_sid(struct irte *irte, int apic)
static int set_hpet_sid(struct irte *irte, u8 id)
static int set_msi_sid_cb(struct pci_dev *pdev, u16 alias, void *opaque)
static int set_msi_sid(struct irte *irte, struct pci_dev *dev)
static int iommu_load_old_irte(struct intel_iommu *iommu)
static void iommu_set_irq_remapping(struct intel_iommu *iommu, int mode)
static void iommu_enable_irq_remapping(struct intel_iommu *iommu)
static int intel_setup_irq_remapping(struct intel_iommu *iommu)
static void intel_teardown_irq_remapping(struct intel_iommu *iommu)
static void iommu_disable_irq_remapping(struct intel_iommu *iommu)
static int __init dmar_x2apic_optout(void)
static void __init intel_cleanup_irq_remapping(void)
static int __init intel_prepare_irq_remapping(void)
static inline void set_irq_posting_cap(void)
static int __init intel_enable_irq_remapping(void)
static int ir_parse_one_hpet_scope(struct acpi_dmar_device_scope *scope, struct intel_iommu *iommu, struct acpi_dmar_hardware_unit *drhd)
static int ir_parse_one_ioapic_scope(struct acpi_dmar_device_scope *scope, struct intel_iommu *iommu, struct acpi_dmar_hardware_unit *drhd)
static int ir_parse_ioapic_hpet_scope(struct acpi_dmar_header *header, struct intel_iommu *iommu)
static void ir_remove_ioapic_hpet_scope(struct intel_iommu *iommu)
static int __init parse_ioapics_under_ir(void)
static int __init ir_dev_scope_init(void)
static void disable_irq_remapping(void)
static int reenable_irq_remapping(int eim)
static void prepare_irte(struct irte *irte, int vector, unsigned int dest)
static struct irq_domain *intel_get_ir_irq_domain(struct irq_alloc_info *info)
static struct irq_domain *intel_get_irq_domain(struct irq_alloc_info *info)
static void intel_ir_reconfigure_irte(struct irq_data *irqd, bool force)
static int intel_ir_set_affinity(struct irq_data *data, const struct cpumask *mask, bool force)
static void intel_ir_compose_msi_msg(struct irq_data *irq_data, struct msi_msg *msg)
static int intel_ir_set_vcpu_affinity(struct irq_data *data, void *info)
static void intel_irq_remapping_prepare_irte(struct intel_ir_data *data, struct irq_cfg *irq_cfg, struct irq_alloc_info *info, int index, int sub_handle)
static void intel_free_irq_resources(struct irq_domain *domain, unsigned int virq, unsigned int nr_irqs)
static int intel_irq_remapping_alloc(struct irq_domain *domain, unsigned int virq, unsigned int nr_irqs, void *arg)
static void intel_irq_remapping_free(struct irq_domain *domain, unsigned int virq, unsigned int nr_irqs)
static int intel_irq_remapping_activate(struct irq_domain *domain, struct irq_data *irq_data, bool reserve)
static void intel_irq_remapping_deactivate(struct irq_domain *domain, struct irq_data *irq_data)
static int dmar_ir_add(struct dmar_drhd_unit *dmaru, struct intel_iommu *iommu)
int dmar_ir_hotplug(struct dmar_drhd_unit *dmaru, bool insert)
\n
     16 struct intel_iommu *iommu
      8 void
      5 struct irte *irte
      5 struct irq_domain *domain
      3 unsigned int virq
      3 unsigned int nr_irqs
      3 struct irq_data *irq_data
      3 struct irq_alloc_info *info
      3 struct irq_2_iommu *irq_iommu
      2 struct pci_dev *dev
      2 struct irq_data *data
      2 struct dmar_drhd_unit *dmaru
      2 struct acpi_dmar_hardware_unit *drhd
      2 struct acpi_dmar_device_scope *scope
      2 int index
      2 int apic
      2 bool force
      1 void *opaque
      1 void *info
      1 void *arg
      1 unsigned int svt
      1 unsigned int sq
      1 unsigned int sid
      1 unsigned int dest
      1 u8 id
      1 u8 hpet_id
      1 u16 count
      1 u16 alias
      1 struct pci_dev *pdev
      1 struct msi_msg *msg
      1 struct irte *irte_modified
      1 struct irq_data *irqd
      1 struct irq_cfg *irq_cfg
      1 struct intel_ir_data *data
      1 struct acpi_dmar_header *header
      1 int vector
      1 int sub_handle
      1 int mode
      1 int mask
      1 int irq
      1 int eim
      1 const struct cpumask *mask
      1 bool reserve
      1 bool insert


text:
package org.apache.solr.cloud;

import org.junit.Test;

/*
 * Implementation moved to AbstractRecoveryZkTestBase as it is used by HDFS contrib tests.
 */
public class RecoveryZkTest extends AbstractRecoveryZkTestBase {

  @Test
  @Override
  public void test() throws Exception {
    super.test();
  }
}


text:
#region Foreign-License

#endregion
using System.Text;
using System.IO;
namespace Tcl.Lang
{

    /// <summary> This class implements the built-in "read" command in Tcl.</summary>

    class ReadCmd : ICommand
    {

        /// <summary> This procedure is invoked to process the "read" Tcl command.
        /// See the user documentation for details on what it does.
        ///
        /// </summary>
        /// <param name="interp">the current interpreter.
        /// </param>
        /// <param name="argv">command arguments.
        /// </param>

        public TCL.CompletionCode CmdProc(Interp interp, TclObject[] argv)
        {

            Channel chan; // The channel being operated on this
            // method
            int i = 1; // Index to the next arg in argv
            int toRead = 0; // Number of bytes or chars to read from channel
            int charactersRead; // Number of bytes or chars read from channel
            bool readAll = true; // If true read-all else toRead
            bool noNewline = false; // If true, strip the newline if there
            TclObject result;

            if ((argv.Length != 2) && (argv.Length != 3))
            {

                errorWrongNumArgs(interp, argv[0].ToString());
            }

            if (argv[i].ToString().Equals("-nonewline"))
            {
                noNewline = true;
                i++;
            }

            if (i == argv.Length)
            {

                errorWrongNumArgs(interp, argv[0].ToString());
            }

            chan = TclIO.getChannel(interp, argv[i].ToString());
            if (chan == null)
            {

                throw new TclException(interp, "can not find channel named \"" + argv[i].ToString() + "\"");
            }

            // Consumed channel name.

            i++;

            // Compute how many bytes or chars to read, and see whether the final
            // noNewline should be dropped.

            if (i < argv.Length)
            {

                string arg = argv[i].ToString();

                if (System.Char.IsDigit(arg[0]))
                {
                    toRead = TclInteger.Get(interp, argv[i]);
                    readAll = false;
                }
                else if (arg.Equals("nonewline"))
                {
                    noNewline = true;
                }
                else
                {
                    throw new TclException(interp, "bad argument \"" + arg + "\": should be \"nonewline\"");
                }
            }

            try
            {
                if ((System.Object)chan.Encoding == null)
                {
                    result = TclByteArray.NewInstance();
                }
                else
                {
                    result = TclString.NewInstance(new StringBuilder(64));
                }
                if (readAll)
                {
                    charactersRead = chan.read(interp, result, TclIO.READ_ALL, 0);

                    // If -nonewline was specified, and we have not hit EOF
                    // and the last char is a "\n", then remove it and return.

                    if (noNewline)
                    {

                        string inStr = result.ToString();
                        if ((charactersRead > 0) && (inStr[charactersRead - 1] == '\n'))
                        {
                            interp.SetResult(inStr.Substring(0, ((charactersRead - 1)) - (0)));
                            return TCL.CompletionCode.RETURN;
                        }
                    }
                }
                else
                {
                    // FIXME: Bug here, the -nonewline flag must be respected
                    // when reading a set number of bytes
                    charactersRead = chan.read(interp, result, TclIO.READ_N_BYTES, toRead);
                }

                /*
                // FIXME: Port this -nonewline logic from the C code.
                if (charactersRead < 0) {
                Tcl_ResetResult(interp);
                Tcl_AppendResult(interp, "error reading \"", name, "\": ",
                Tcl_PosixError(interp), (char *) NULL);
                Tcl_DecrRefCount(resultPtr);
                return TCL_ERROR;
                }

                // If requested, remove the last newline in the channel if at EOF.

                if ((charactersRead > 0) && (newline != 0)) {
                char *result;
                int length;

                result = Tcl_GetStringFromObj(resultPtr, length);
                if (result[length - 1] == '\n') {
                Tcl_SetObjLength(resultPtr, length - 1);
                }
                }

                */

                interp.SetResult(result);
            }
            catch (IOException e)
            {
                throw new TclRuntimeError("ReadCmd.cmdProc() Error: IOException when reading " + chan.ChanName);
            }
            return TCL.CompletionCode.RETURN;
        }

        /// <summary> A unique error msg is printed for read, therefore dont call this
        /// instead of the standard TclNumArgsException().
        ///
        /// </summary>
        /// <param name="interp">the current interpreter.
        /// </param>
        /// <param name="cmd">the name of the command (extracted form argv[0] of cmdProc)
        /// </param>

        private void errorWrongNumArgs(Interp interp, string cmd)
        {
            throw new TclException(interp, "wrong # args: should be \"" + "read channelId ?numChars?\" " + "or \"read ?-nonewline? channelId\"");
        }
    }
}


text:
using namespace Gaffer;
using namespace GafferScene;

IE_CORE_DEFINERUNTIMETYPED( ShaderSwitch );

ShaderSwitch::ShaderSwitch( const std::string &name )
	:	SwitchComputeNode( name )
{
}

ShaderSwitch::~ShaderSwitch()
{
}


text:
package com.marcelmika.lims.core.service;

import com.marcelmika.lims.api.events.group.GetGroupsRequestEvent;
import com.marcelmika.lims.api.events.group.GetGroupsResponseEvent;

/**
 * @author Ing. Marcel Mika
 * @link http://marcelmika.com
 * Date: 4/1/14
 * Time: 8:38 PM
 */
public interface GroupCoreService {

    /**
     * Get all groups related to the particular user
     *
     * @param event request event for method
     * @return response event for  method
     */
    public GetGroupsResponseEvent getGroups(GetGroupsRequestEvent event);

}


text:
from pyspark import since, keyword_only
from pyspark.ml.param.shared import *
from pyspark.ml.util import *
from pyspark.ml.wrapper import JavaEstimator, JavaModel, JavaParams, \
    JavaPredictor, JavaPredictionModel
from pyspark.ml.common import inherit_doc, _java2py, _py2java

@inherit_doc
class _DecisionTreeModel(JavaPredictionModel):
    """
    Abstraction for Decision Tree models.

    .. versionadded:: 1.5.0
    """

    @property
    @since("1.5.0")
    def numNodes(self):
        """Return number of nodes of the decision tree."""
        return self._call_java("numNodes")

    @property
    @since("1.5.0")
    def depth(self):
        """Return depth of the decision tree."""
        return self._call_java("depth")

    @property
    @since("2.0.0")
    def toDebugString(self):
        """Full description of model."""
        return self._call_java("toDebugString")

    @since("3.0.0")
    def predictLeaf(self, value):
        """
        Predict the indices of the leaves corresponding to the feature vector.
        """
        return self._call_java("predictLeaf", value)

class _DecisionTreeParams(HasCheckpointInterval, HasSeed, HasWeightCol):
    """
    Mixin for Decision Tree parameters.
    """

    leafCol = Param(Params._dummy(), "leafCol", "Leaf indices column name. Predicted leaf " +
                    "index of each instance in each tree by preorder.",
                    typeConverter=TypeConverters.toString)

    maxDepth = Param(Params._dummy(), "maxDepth", "Maximum depth of the tree. (>= 0) E.g., " +
                     "depth 0 means 1 leaf node; depth 1 means 1 internal node + 2 leaf nodes.",
                     typeConverter=TypeConverters.toInt)

    maxBins = Param(Params._dummy(), "maxBins", "Max number of bins for discretizing continuous " +
                    "features.  Must be >=2 and >= number of categories for any categorical " +
                    "feature.", typeConverter=TypeConverters.toInt)

    minInstancesPerNode = Param(Params._dummy(), "minInstancesPerNode", "Minimum number of " +
                                "instances each child must have after split. If a split causes " +
                                "the left or right child to have fewer than " +
                                "minInstancesPerNode, the split will be discarded as invalid. " +
                                "Should be >= 1.", typeConverter=TypeConverters.toInt)

    minWeightFractionPerNode = Param(Params._dummy(), "minWeightFractionPerNode", "Minimum "
                                     "fraction of the weighted sample count that each child "
                                     "must have after split. If a split causes the fraction "
                                     "of the total weight in the left or right child to be "
                                     "less than minWeightFractionPerNode, the split will be "
                                     "discarded as invalid. Should be in interval [0.0, 0.5).",
                                     typeConverter=TypeConverters.toFloat)

    minInfoGain = Param(Params._dummy(), "minInfoGain", "Minimum information gain for a split " +
                        "to be considered at a tree node.", typeConverter=TypeConverters.toFloat)

    maxMemoryInMB = Param(Params._dummy(), "maxMemoryInMB", "Maximum memory in MB allocated to " +
                          "histogram aggregation. If too small, then 1 node will be split per " +
                          "iteration, and its aggregates may exceed this size.",
                          typeConverter=TypeConverters.toInt)

    cacheNodeIds = Param(Params._dummy(), "cacheNodeIds", "If false, the algorithm will pass " +
                         "trees to executors to match instances with nodes. If true, the " +
                         "algorithm will cache node IDs for each instance. Caching can speed " +
                         "up training of deeper trees. Users can set how often should the cache " +
                         "be checkpointed or disable it by setting checkpointInterval.",
                         typeConverter=TypeConverters.toBoolean)

    def __init__(self):
        super(_DecisionTreeParams, self).__init__()

    def setLeafCol(self, value):
        """
        Sets the value of :py:attr:`leafCol`.
        """
        return self._set(leafCol=value)

    def getLeafCol(self):
        """
        Gets the value of leafCol or its default value.
        """
        return self.getOrDefault(self.leafCol)

    def getMaxDepth(self):
        """
        Gets the value of maxDepth or its default value.
        """
        return self.getOrDefault(self.maxDepth)

    def getMaxBins(self):
        """
        Gets the value of maxBins or its default value.
        """
        return self.getOrDefault(self.maxBins)

    def getMinInstancesPerNode(self):
        """
        Gets the value of minInstancesPerNode or its default value.
        """
        return self.getOrDefault(self.minInstancesPerNode)

    def getMinWeightFractionPerNode(self):
        """
        Gets the value of minWeightFractionPerNode or its default value.
        """
        return self.getOrDefault(self.minWeightFractionPerNode)

    def getMinInfoGain(self):
        """
        Gets the value of minInfoGain or its default value.
        """
        return self.getOrDefault(self.minInfoGain)

    def getMaxMemoryInMB(self):
        """
        Gets the value of maxMemoryInMB or its default value.
        """
        return self.getOrDefault(self.maxMemoryInMB)

    def getCacheNodeIds(self):
        """
        Gets the value of cacheNodeIds or its default value.
        """
        return self.getOrDefault(self.cacheNodeIds)

@inherit_doc
class _TreeEnsembleModel(JavaPredictionModel):
    """
    (private abstraction)
    Represents a tree ensemble model.
    """

    @property
    @since("2.0.0")
    def trees(self):
        """Trees in this ensemble. Warning: These have null parent Estimators."""
        return [_DecisionTreeModel(m) for m in list(self._call_java("trees"))]

    @property
    @since("2.0.0")
    def getNumTrees(self):
        """Number of trees in ensemble."""
        return self._call_java("getNumTrees")

    @property
    @since("1.5.0")
    def treeWeights(self):
        """Return the weights for each tree"""
        return list(self._call_java("javaTreeWeights"))

    @property
    @since("2.0.0")
    def totalNumNodes(self):
        """Total number of nodes, summed over all trees in the ensemble."""
        return self._call_java("totalNumNodes")

    @property
    @since("2.0.0")
    def toDebugString(self):
        """Full description of model."""
        return self._call_java("toDebugString")

    @since("3.0.0")
    def predictLeaf(self, value):
        """
        Predict the indices of the leaves corresponding to the feature vector.
        """
        return self._call_java("predictLeaf", value)

class _TreeEnsembleParams(_DecisionTreeParams):
    """
    Mixin for Decision Tree-based ensemble algorithms parameters.
    """

    subsamplingRate = Param(Params._dummy(), "subsamplingRate", "Fraction of the training data " +
                            "used for learning each decision tree, in range (0, 1].",
                            typeConverter=TypeConverters.toFloat)

    supportedFeatureSubsetStrategies = ["auto", "all", "onethird", "sqrt", "log2"]

    featureSubsetStrategy = \
        Param(Params._dummy(), "featureSubsetStrategy",
              "The number of features to consider for splits at each tree node. Supported " +
              "options: 'auto' (choose automatically for task: If numTrees == 1, set to " +
              "'all'. If numTrees > 1 (forest), set to 'sqrt' for classification and to " +
              "'onethird' for regression), 'all' (use all features), 'onethird' (use " +
              "1/3 of the features), 'sqrt' (use sqrt(number of features)), 'log2' (use " +
              "log2(number of features)), 'n' (when n is in the range (0, 1.0], use " +
              "n * number of features. When n is in the range (1, number of features), use" +
              " n features). default = 'auto'", typeConverter=TypeConverters.toString)

    def __init__(self):
        super(_TreeEnsembleParams, self).__init__()

    @since("1.4.0")
    def getSubsamplingRate(self):
        """
        Gets the value of subsamplingRate or its default value.
        """
        return self.getOrDefault(self.subsamplingRate)

    @since("1.4.0")
    def getFeatureSubsetStrategy(self):
        """
        Gets the value of featureSubsetStrategy or its default value.
        """
        return self.getOrDefault(self.featureSubsetStrategy)

class _RandomForestParams(_TreeEnsembleParams):
    """
    Private class to track supported random forest parameters.
    """

    numTrees = Param(Params._dummy(), "numTrees", "Number of trees to train (>= 1).",
                     typeConverter=TypeConverters.toInt)

    bootstrap = Param(Params._dummy(), "bootstrap", "Whether bootstrap samples are used "
                      "when building trees.", typeConverter=TypeConverters.toBoolean)

    def __init__(self):
        super(_RandomForestParams, self).__init__()

    @since("1.4.0")
    def getNumTrees(self):
        """
        Gets the value of numTrees or its default value.
        """
        return self.getOrDefault(self.numTrees)

    @since("3.0.0")
    def getBootstrap(self):
        """
        Gets the value of bootstrap or its default value.
        """
        return self.getOrDefault(self.bootstrap)

class _GBTParams(_TreeEnsembleParams, HasMaxIter, HasStepSize, HasValidationIndicatorCol):
    """
    Private class to track supported GBT params.
    """

    stepSize = Param(Params._dummy(), "stepSize",
                     "Step size (a.k.a. learning rate) in interval (0, 1] for shrinking " +
                     "the contribution of each estimator.",
                     typeConverter=TypeConverters.toFloat)

    validationTol = Param(Params._dummy(), "validationTol",
                          "Threshold for stopping early when fit with validation is used. " +
                          "If the error rate on the validation input changes by less than the " +
                          "validationTol, then learning will stop early (before `maxIter`). " +
                          "This parameter is ignored when fit without validation is used.",
                          typeConverter=TypeConverters.toFloat)

    @since("3.0.0")
    def getValidationTol(self):
        """
        Gets the value of validationTol or its default value.
        """
        return self.getOrDefault(self.validationTol)

class _HasVarianceImpurity(Params):
    """
    Private class to track supported impurity measures.
    """

    supportedImpurities = ["variance"]

    impurity = Param(Params._dummy(), "impurity",
                     "Criterion used for information gain calculation (case-insensitive). " +
                     "Supported options: " +
                     ", ".join(supportedImpurities), typeConverter=TypeConverters.toString)

    def __init__(self):
        super(_HasVarianceImpurity, self).__init__()

    @since("1.4.0")
    def getImpurity(self):
        """
        Gets the value of impurity or its default value.
        """
        return self.getOrDefault(self.impurity)

class _TreeClassifierParams(Params):
    """
    Private class to track supported impurity measures.

    .. versionadded:: 1.4.0
    """

    supportedImpurities = ["entropy", "gini"]

    impurity = Param(Params._dummy(), "impurity",
                     "Criterion used for information gain calculation (case-insensitive). " +
                     "Supported options: " +
                     ", ".join(supportedImpurities), typeConverter=TypeConverters.toString)

    def __init__(self):
        super(_TreeClassifierParams, self).__init__()

    @since("1.6.0")
    def getImpurity(self):
        """
        Gets the value of impurity or its default value.
        """
        return self.getOrDefault(self.impurity)

class _TreeRegressorParams(_HasVarianceImpurity):
    """
    Private class to track supported impurity measures.
    """
    pass


text:
<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
<meta name=Generator content="Microsoft Word 15 (filtered)">

Tanner Johnson

[contact
information withheld]

Education

B.S.
degree candidate, Information Technology, Brigham Young University

·
Computer
Science, Minor

·
Expected
graduation date: April 2016

·
Cumulative
GPA: 3.61/4.0

Experience

Developer/Systems Admin, Slab
Pizza, Provo, Utah, June 2013-Present

·
Developed
custom POS and pizza managing software

·
Improved
pizza-make time by 30%

·
Decreased
customer wait time by 2 minutes

·
Increased
slabpizza.com page visit amount by 80%

Volunteer
Representative,
Honduras, May 2010-May 2012

·
Directed
and trained over 100 volunteer representatives

·
Worked
10-12 hour days for two years

Skills

Computer Languages/Frameworks:

·
HTML,
CSS, JavaScript, jQuery

·
PHP,
SQL, C++, Java, Python, Racket

Computer:

·
Database
design, web application development, web design

·
Search
engine optimization, online marketing, WordPress

·
Linux,
Windows, computer networking

·
Apache,
Linux servers

Language:

·
Spanish,
conversational oral and written

Strengths:

·
hard-working,
quick learner, detail oriented

Affiliations/
Awards/ Activities

Boy Scouts of America

·
Achieved the
rank of Eagle Scout

·
Volunteered in multiple
summer camps as a leader for 6 years


text:
// P_2_2_1_02
//
// Generative Gestaltung – Creative Coding im Web
// ISBN: 978-3-87439-902-9, First Edition, Hermann Schmidt, Mainz, 2018
// Benedikt Groß, Hartmut Bohnacker, Julia Laub, Claudius Lazzeroni
// with contributions by Joey Lee and Niels Poldervaart
// Copyright 2018
//
// http://www.generative-gestaltung.de
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * draw the path of a stupid agent
 *
 * MOUSE
 * position x          : drawing speed
 *
 * KEYS
 * 1-3                 : draw mode of the agent
 * r                   : clear display
 * s                   : save png
 */
use nannou::prelude::*;

enum Direction {
    North,
    NorthEast,
    East,
    SouthEast,
    South,
    SouthWest,
    West,
    NorthWest,
}

fn main() {
    nannou::app(model).update(update).run();
}

struct Model {
    pos_x: f32,
    pos_y: f32,
    positions: Vec<Point2>,
    counter_triggers: Vec<bool>,
    step_size: f32,
    radius: f32,
    direction: Direction,
    draw_mode: u8,
    // p5js counter max ~9 quadrillion... our max ~18 quintillion
    counter: u64,
}

fn model(app: &App) -> Model {
    let _window = app
        .new_window()
        .size(600, 600)
        .view(view)
        .key_released(key_released)
        .build()
        .unwrap();

    Model {
        pos_x: 0.0,
        pos_y: 0.0,
        positions: vec![pt2(0.0, 0.0); 600],
        counter_triggers: vec![false; 600],
        step_size: 1.0,
        radius: 1.0,
        direction: Direction::North,
        draw_mode: 0,
        counter: 0,
    }
}

fn update(app: &App, model: &mut Model, _update: Update) {
    let win = app.window_rect();
    let mx = clamp(
        map_range(app.mouse.x, win.left(), win.right(), 0.0, win.w()),
        0.0,
        win.w(),
    ) as usize;
    model.positions.resize(mx + 1, pt2(0.0, 0.0));
    model.counter_triggers.resize(mx + 1, false);
    for i in 0..=mx {
        model.counter += 1;

        let r = if model.draw_mode == 2 {
            random_range(0, 3)
        } else {
            random_range(0, 8)
        };
        model.direction = match r {
            0 => Direction::North,
            1 => Direction::NorthEast,
            2 => Direction::East,
            3 => Direction::SouthEast,
            4 => Direction::South,
            5 => Direction::SouthWest,
            6 => Direction::West,
            7 => Direction::NorthWest,
            _ => Direction::North,
        };
        match model.direction {
            Direction::North => model.pos_y -= model.step_size,
            Direction::NorthEast => {
                model.pos_x += model.step_size;
                model.pos_y -= model.step_size
            }
            Direction::East => {
                model.pos_x += model.step_size;
            }
            Direction::SouthEast => {
                model.pos_x += model.step_size;
                model.pos_y += model.step_size
            }
            Direction::South => model.pos_y += model.step_size,
            Direction::SouthWest => {
                model.pos_x -= model.step_size;
                model.pos_y += model.step_size
            }
            Direction::West => {
                model.pos_x -= model.step_size;
            }
            Direction::NorthWest => {
                model.pos_x -= model.step_size;
                model.pos_y -= model.step_size
            }
        }

        if model.pos_x > win.right() {
            model.pos_x = win.left();
        }
        if model.pos_x < win.left() {
            model.pos_x = win.right();
        }
        if model.pos_y < win.bottom() {
            model.pos_y = win.top();
        }
        if model.pos_y > win.top() {
            model.pos_y = win.bottom();
        }

        if model.draw_mode == 3 {
            if model.counter >= 100 {
                model.counter_triggers[i] = true;
                model.counter = 0;
            } else {
                model.counter_triggers[i] = false;
            }
        }

        model.positions[i] = pt2(model.pos_x, model.pos_y);
    }
}

fn view(app: &App, model: &Model, frame: Frame) {
    let draw = app.draw();

    if frame.nth() == 0 || app.keys.down.contains(&Key::R) {
        draw.background().color(WHITE);
    }

    model.positions.iter().enumerate().for_each(|(i, pos)| {
        if model.draw_mode == 3 && model.counter_triggers[i] == true {
            draw.ellipse()
                .x_y(pos.x + model.step_size / 2.0, pos.y + model.step_size / 2.0)
                .radius(model.radius + 3.5)
                .hsva(0.53, 1.0, 0.64, 0.8);
        }
        draw.ellipse()
            .x_y(pos.x + model.step_size / 2.0, pos.y + model.step_size / 2.0)
            .radius(model.radius)
            .rgba(0.0, 0.0, 0.0, 0.15);
    });
    // Write to the window frame.
    draw.to_frame(app, &frame).unwrap();
}

fn key_released(app: &App, model: &mut Model, key: Key) {
    match key {
        Key::S => {
            app.main_window()
                .capture_frame(app.exe_name().unwrap() + ".png");
        }
        Key::Key1 => {
            model.draw_mode = 1;
            model.step_size = 1.0;
            model.radius = 1.0;
        }
        Key::Key2 => {
            model.draw_mode = 2;
            model.step_size = 1.0;
            model.radius = 1.0;
        }
        Key::Key3 => {
            model.draw_mode = 3;
            model.step_size = 10.0;
            model.radius = 2.5;
        }
        _ => (),
    }
}


text:
#pragma once

#include <string>

namespace graph {

		/*! \brief A weight property.
		 *
		 * This can be used to have weighted arcs or weighted nodes.
		 */
		struct WeightedProperty {
			/*! \brief The weight.
			 */
			int weight;

			/*! \brief Compare two weights
			 *
			 * \param other the other property to which compare.
			 */
		    bool operator==(WeightedProperty const& other) const {
			    return weight == other.weight;
		    }
		};

		/*! \brief Add typical A* node properties with a intermediate state.
		 */
		template <typename State>
		struct AstarNodeProperty {

			/*! \brief the \f$g(n)\f$ of the node.
			 */
			int gScore;

			/*! \brief the \f$h(n)\f$ of the node.
			 */
			int hScore;

			/*! \brief The intermediate state
			 */
			State state;

			/*! \brief Compare two A* properties
			 *
			 * \param other the other property to which compare.
			 */
		    bool operator==(AstarNodeProperty const& other) const {
			    return (gScore == other.gScore) && (hScore == other.hScore) &&
			           (state == other.state);
		    }
		};

		/*! \brief Add typical A* node properties without a intermediate state.
		 */
		template <>
		struct AstarNodeProperty<void> {

			/*! \brief the \f$g(n)\f$ of the node.
			 */
			int gScore;

			/*! \brief the \f$h(n)\f$ of the node.
			 */
			int hScore;

			/*! \brief Compare two A* properties
			 *
			 * \param other the other property to which compare.
			 */
		    bool operator==(AstarNodeProperty const& other) const {
			    return (gScore == other.gScore) && (hScore == other.hScore);
		    }
		};

		/*! \brief Placeholder to not have any properties.
		 */
	    struct NoProperty {
			/*! \brief Compare nothing
			 *
			 * Always return true.
			 */
		    bool operator==(NoProperty const&) const {
			    return true;
		    }
	    };
}


text:
"Filters related views"

import inspect
from rest_framework.decorators import api_view
from rest_framework.response import Response
from guardian.shortcuts import get_perms
from django.shortcuts import get_object_or_404
from django.db.models import Max
from backend import models, filters

@api_view(['GET'])
def filters_list(request, uuid):
    "List all filters in a given layer"
    layer = get_object_or_404(models.Layer, uuid=uuid)
    if 'view_namespace' in get_perms(request.user, layer.workflow.namespace):
        return Response([
            {
                'uuid': fil.uuid,
                'name': fil.name,
                'target': fil.target,
                'configurations': [
                    {
                        'uuid': config.uuid,
                        'key': config.key,
                        'value': {
                            'name': config.value.name,
                            'value': config.value.value
                        }
                    } for config in fil.configurations
                ],
                'links': [
                    {
                        'uuid': link.uuid,
                        'from': link.origin_node,
                        'to_filter': link.target_filter.name,
                        'to_uuid': link.target_filter.uuid,
                        'to_node': link.target_node
                    } for link in fil.links
                ],
                'links_in': [
                    {
                        'uuid': link.uuid,
                        'from_filter': link.origin_filter.name,
                        'from_uuid': link.origin_filter.uuid,
                        'from_node': link.origin_node,
                        'to': link.target_node
                    } for link in fil.links_in
                ]
            } for fil in layer.filters
        ])
    return Response([])

@api_view(['GET'])
def filters_types(_):
    "List all available filters"
    possibilities = inspect.getmembers(filters, inspect.isclass)
    return Response([
        {
            'slug': fil[0],
            'name': fil[1].name,
            'description': fil[1].description,
            'node_in': fil[1].node_in,
            'node_out': fil[1].node_out,
            'parameters': fil[1].parameters
        } for fil in possibilities
    ])

@api_view(['POST'])
def filter_create(request, uuid):
    "Create a filter in a layer"
    layer = get_object_or_404(models.Layer, uuid=uuid)
    if 'view_namespace' in get_perms(request.user, layer.workflow.namespace):
        name = request.POST['name']
        target = request.POST['target']
        weight = models.Filter.objects.filter(layer=layer).aggregate(Max('weight'))
        if weight['weight__max'] is not None:
            models.Filter.objects.create(
                name=name,
                target=target,
                weight=(weight['weight__max'] + 1),
                layer=layer
            )
        else:
            models.Filter.objects.create(
                name=name,
                target=target,
                weight=0,
                layer=layer
            )
        return Response({'success': True})
    return Response({'success': False})

@api_view(['POST'])
def filter_move(request, uuid):
    "Move a filter"
    fil = get_object_or_404(models.Filter, uuid=uuid)
    if 'view_namespace' in get_perms(request.user, fil.layer.workflow.namespace):
        if request.POST['direction'] == '0':
            other_filter = models.Filter.objects.filter(
                layer=fil.layer,
                weight__gt=fil.weight
            ).earliest('weight')
        else:
            other_filter = models.Filter.objects.filter(
                layer=fil.layer,
                weight__lt=fil.weight
            ).latest('weight')
        if other_filter is None:
            return Response({'success': False})
        tmp = other_filter.weight
        other_filter.weight = fil.weight
        fil.weight = tmp
        fil.save()
        other_filter.save()
        return Response({'success': True})
    return Response({'success': False})

@api_view(['DELETE'])
def filter_delete(request, uuid):
    "Delete a filter"
    fil = get_object_or_404(models.Filter, uuid=uuid)
    if 'view_namespace' in get_perms(request.user, fil.layer.workflow.namespace):
        fil.delete()
        return Response({'success': True})
    return Response({'success': False})

@api_view(['POST'])
def filter_configure(request):
    "Set a configuration for a filter"
    filter_uuid = request.POST['filter']
    fil = get_object_or_404(models.Filter, uuid=filter_uuid)
    if 'view_namespace' in get_perms(request.user, fil.layer.workflow.namespace):
        variable_uuid = request.POST['variable']
        variable = get_object_or_404(models.Variable, uuid=variable_uuid)
        if 'view_namespace' in get_perms(request.user, variable.group.namespace):
            target = getattr(filters, fil.target)
            key = request.POST['key']
            for param in target.parameters:
                if param['key'] == key:
                    if param['type'] == variable.type_class.slug:
                        models.Configuration.objects.filter(target=fil, key=key).delete()
                        models.Configuration.objects.create(target=fil, key=key, value=variable)
                        return Response({'success': True})
                    else:
                        return Response({'success': False}) # break loop
    return Response({'success': False})

@api_view(['POST'])
def filter_link(request):
    "Set a link between two filters"
    origin_filter_uuid = request.POST['origin_filter']
    target_filter_uuid = request.POST['target_filter']
    origin_filter = get_object_or_404(models.Filter, uuid=origin_filter_uuid)
    target_filter = get_object_or_404(models.Filter, uuid=target_filter_uuid)
    if 'view_namespace' in get_perms(request.user, origin_filter.layer.workflow.namespace)\
        and origin_filter.layer.workflow == target_filter.layer.workflow:
        origin_node = request.POST['origin_node']
        target_node = request.POST['target_node']
        try:
            link = models.Link.objects.get(target_filter=target_filter, target_node=target_node)
        except models.Link.DoesNotExist:
            models.Link.objects.create(
                origin_filter=origin_filter,
                origin_node=origin_node,
                target_filter=target_filter,
                target_node=target_node
            )
            return Response({'succes': True})
        link.origin_filter = origin_filter
        link.origin_node = origin_node
        link.save()
        return Response({'success': True})
    return Response({'success': False})

@api_view(['DELETE'])
def link_delete(request, uuid):
    "Delete a link between filters"
    link = get_object_or_404(models.Link, uuid=uuid)
    if 'view_namespace' in get_perms(request.user, link.origin_filter.layer.workflow.namespace):
        link.delete()
        return Response({'success': True})
    return Response({'success': False})


text:
var foo = exports.foo = require('./folder/foo');

exports.hello = 'hello';
exports.sayHello = function() {
  return foo.hello();
};
exports.calledFromFoo = function() {
  return exports.hello;
};


text:
<?php

/**
 * Filter item model
 *
 * @category    Mage
 * @package     Mage_Catalog
 * @author      Magento Core Team <core@magentocommerce.com>
 */
class Mage_Catalog_Model_Layer_Filter_Item extends Varien_Object
{
    /**
     * Get filter instance
     *
     * @return Mage_Catalog_Model_Layer_Filter_Abstract
     */
    public function getFilter()
    {
        $filter = $this->getData('filter');
        if (!is_object($filter)) {
            Mage::throwException(
                Mage::helper('catalog')->__('Filter must be an object. Please set correct filter.')
            );
        }
        return $filter;
    }

    /**
     * Get filter item url
     *
     * @return string
     */
    public function getUrl()
    {
        $query = array(
            $this->getFilter()->getRequestVar()=>$this->getValue(),
            Mage::getBlockSingleton('page/html_pager')->getPageVarName() => null // exclude current page from urls
        );
        return Mage::getUrl('*/*/*', array('_current'=>true, '_use_rewrite'=>true, '_query'=>$query));
    }

    /**
     * Get url for remove item from filter
     *
     * @return string
     */
    public function getRemoveUrl()
    {
        $query = array($this->getFilter()->getRequestVar()=>$this->getFilter()->getResetValue());
        $params['_current']     = true;
        $params['_use_rewrite'] = true;
        $params['_query']       = $query;
        $params['_escape']      = true;
        return Mage::getUrl('*/*/*', $params);
    }

    /**
     * Get url for "clear" link
     *
     * @return false|string
     */
    public function getClearLinkUrl()
    {
        $clearLinkText = $this->getFilter()->getClearLinkText();
        if (!$clearLinkText) {
            return false;
        }

        $urlParams = array(
            '_current' => true,
            '_use_rewrite' => true,
            '_query' => array($this->getFilter()->getRequestVar() => null),
            '_escape' => true,
        );
        return Mage::getUrl('*/*/*', $urlParams);
    }

    /**
     * Get item filter name
     *
     * @return string
     */
    public function getName()
    {
        return $this->getFilter()->getName();
    }

    /**
     * Get item value as string
     *
     * @return string
     */
    public function getValueString()
    {
        $value = $this->getValue();
        if (is_array($value)) {
            return implode(',', $value);
        }
        return $value;
    }
}


text:
<Record>
<Term>Poor Vascular Access</Term>
<SemanticType>Disease or Syndrome</SemanticType>
<ParentTerm>Non-Neoplastic Vascular Disorder</ParentTerm>
<ClassificationPath>Findings_and_Disorders_Kind/Disease, Disorder or Finding/Disease or Disorder/Disorder by Site/Cardiovascular Disorder/Vascular Disorder/Non-Neoplastic Vascular Disorder/Poor Vascular Access</ClassificationPath>
<BroaderTerm>Poor Vascular Access</BroaderTerm>
<BroaderTerm>Vascular Disorder</BroaderTerm>
<BroaderTerm>Disease or Disorder</BroaderTerm>
<BroaderTerm>Non-Neoplastic Vascular Disorder</BroaderTerm>
<BroaderTerm>Disorder by Site</BroaderTerm>
<BroaderTerm>Cardiovascular Disorder</BroaderTerm>
<BroaderTerm>Disease, Disorder or Finding</BroaderTerm>
<BroaderTerm>Findings_and_Disorders_Kind</BroaderTerm>
<Synonym>Poor Vascular Access</Synonym>
<Description>A situation describing a high degree of difficultly as it relates to intravenous and/or intra-arterial access of an individual's vascular system.</Description>
<Source>NCI Thesaurus</Source>
</Record>


text:
class CreateWeixinMediaNews < ActiveRecord::Migration
  def change
    create_table :weixin_media_news do |t|
      t.datetime :planned_send_time
      t.datetime :send_time
      t.string :user_group_name
      t.string :media_id
      t.datetime :upload_time
      t.boolean :is_to_all
      t.integer :sent_count
      t.integer :total_count
      t.integer :filter_count
      t.integer :status
      t.integer :public_account_id
      t.timestamps
    end
  end
end


text:
<?xml version="1.0" encoding="UTF-8"?>
<project>
	<extend>../ImagingRoot/project.xml</extend>
    <pomVersion>1</pomVersion>
    <artifactId>VistaDataSource</artifactId>
    <name>VistaDataSource</name>
	<package>gov.va.med.imaging.url.vista</package>
	<shortDescription>VistA Data Source</shortDescription>
	<build>
		<sourceDirectory>main/src/java</sourceDirectory>
		<unitTestSourceDirectory>main/test/java</unitTestSourceDirectory>
		<unitTest>
			<includes>
				<include>**/Test*.java</include>
			</includes>
			<excludes>
				<exclude>**/TestVistaSession.java</exclude>
			</excludes>
			<resources>
				<resource>
					<directory>main/test/resources</directory>
					<includes>
						<include>**/*</include>
					</includes>
					<filtering>false</filtering>
				</resource>
			</resources>
		</unitTest>
		<resources>
			<resource>
				<directory>main/src/resources</directory>
				<includes>
					<include>**/*</include>
				</includes>
				<filtering>false</filtering>
			</resource>
		</resources>
	</build>
  <dependencies>
    <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>CoreValueObjects</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>DataSourceServiceProvider</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>TransactionContext</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>ImagingCommon</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>ImagingDicomCommon</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>ImagingVistaRealmClient</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>ImageConversion</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>ImagingTestResources</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>
     <dependency>
      <groupId>${pom.groupId}</groupId>
      <artifactId>VistaStorage</artifactId>
      <version>${pom.currentVersion}</version>
      <type>jar</type>
    </dependency>

    <!-- Non-Imaging dependencies -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.14</version>
      <type>jar</type>
    </dependency>
    <!--
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>1.4</version>
      <type>jar</type>
    </dependency>
     -->
  </dependencies>
</project>


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

    <title>ODNC - Developers' Documentation — ODNC 2.7.8 documentation</title>

    <link rel="stylesheet" href="_static/default.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />

    <link rel="top" title="ODNC 2.7.8 documentation" href="index.html" />
    <link rel="next" title="Police Scraper" href="scraper.html" />
    <link rel="prev" title="Welcome to odnc's documentation!" href="index.html" />

Navigation

          index

          next |

          previous |

ODNC 2.7.8 documentation »

ODNC - Developers’ Documentation¶

Intro¶

Welcome to the developers’ documentation for the Open Data NC project! This project was built using Python 2.7.8.
The web framework used is Django 1.7, and this documentation is built using Sphinx 1.2.3.

4 Python modules are used to build the ODNC website:

Police Report Scraper

Scraper to Django interface

Django to web interface

Interactive user-facing website

Table Of Contents

ODNC - Developers’ Documentation

Intro

Previous topic

Welcome to odnc’s documentation!

Next topic

Police Scraper

This Page

Show Source

Quick search

    <form class="search" action="search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>

    Enter search terms or a module, class or function name.

Navigation

          index

          next |

          previous |

ODNC 2.7.8 documentation »

        © Copyright 2014, ODNC Team.
      Created using Sphinx 1.2.3.


text:
/// <reference types="node" />
import * as os from 'os';
import * as ts from 'typescript';

import {absoluteFrom} from './helpers';
import {FileSystem} from './types';

export class NgtscCompilerHost implements ts.CompilerHost {
  constructor(protected fs: FileSystem, protected options: ts.CompilerOptions = {}) {}

  getSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile|undefined {
    const text = this.readFile(fileName);
    return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion, true) :
                                undefined;
  }

  getDefaultLibFileName(options: ts.CompilerOptions): string {
    return this.fs.join(this.getDefaultLibLocation(), ts.getDefaultLibFileName(options));
  }

  getDefaultLibLocation(): string {
    return this.fs.getDefaultLibLocation();
  }

  writeFile(
      fileName: string, data: string, writeByteOrderMark: boolean,
      onError: ((message: string) => void)|undefined,
      sourceFiles?: ReadonlyArray<ts.SourceFile>): void {
    const path = absoluteFrom(fileName);
    this.fs.ensureDir(this.fs.dirname(path));
    this.fs.writeFile(path, data);
  }

  getCurrentDirectory(): string {
    return this.fs.pwd();
  }

  getCanonicalFileName(fileName: string): string {
    return this.useCaseSensitiveFileNames() ? fileName : fileName.toLowerCase();
  }

  useCaseSensitiveFileNames(): boolean {
    return this.fs.isCaseSensitive();
  }

  getNewLine(): string {
    switch (this.options.newLine) {
      case ts.NewLineKind.CarriageReturnLineFeed:
        return '\r\n';
      case ts.NewLineKind.LineFeed:
        return '\n';
      default:
        return os.EOL;
    }
  }

  fileExists(fileName: string): boolean {
    const absPath = this.fs.resolve(fileName);
    return this.fs.exists(absPath) && this.fs.stat(absPath).isFile();
  }

  readFile(fileName: string): string|undefined {
    const absPath = this.fs.resolve(fileName);
    if (!this.fileExists(absPath)) {
      return undefined;
    }
    return this.fs.readFile(absPath);
  }
}


text:
    /**
     * A subclass of JavaFileObject representing regular files.
     */
    private class RegularFileObject extends BaseFileObject {
        /** Have the parent directories been created?
         */
        private boolean hasParents=false;

        /** The file's name.
         */
        private String name;

        /** The underlying file.
         */
        final File f;

        public RegularFileObject(File f) {
            this(f.getName(), f);
        }

        public RegularFileObject(String name, File f) {
            DEBUG.P(this,"RegularFileObject(2)");
            DEBUG.P("name="+name);
            DEBUG.P("f="+f);
            DEBUG.P("f.isDirectory()="+f.isDirectory());

            if (f.isDirectory())
                throw new IllegalArgumentException("directories not supported");
            this.name = name;
            this.f = f;

            DEBUG.P(0,this,"RegularFileObject(2)");
        }

        public InputStream openInputStream() throws IOException {
            return new FileInputStream(f);
        }

        protected CharsetDecoder getDecoder(boolean ignoreEncodingErrors) {
            return JavacFileManager.this.getDecoder(getEncodingName(), ignoreEncodingErrors);
        }

        public OutputStream openOutputStream() throws IOException {
            ensureParentDirectoriesExist();
            return new FileOutputStream(f);
        }

        public Writer openWriter() throws IOException {
            ensureParentDirectoriesExist();
            return new OutputStreamWriter(new FileOutputStream(f), getEncodingName());
        }

        private void ensureParentDirectoriesExist() throws IOException {
            if (!hasParents) {
                File parent = f.getParentFile();
                if (parent != null && !parent.exists()) {
                    if (!parent.mkdirs()) {
                        // if the mkdirs failed, it may be because another process concurrently
                        // created the directory, so check if the directory got created
                        // anyway before throwing an exception
                        if (!parent.exists() || !parent.isDirectory())
                            throw new IOException("could not create parent directories");
                    }
                }
                hasParents = true;
            }
        }

        /** @deprecated see bug 6410637 */
        @Deprecated
        public String getName() {
            return name;
        }

        public boolean isNameCompatible(String cn, JavaFileObject.Kind kind) {
            try {//我加上的
            DEBUG.P(this,"isNameCompatible(2)");

            cn.getClass(); // null check
            //getKind()是在超类BaseFileObject中定义
            if (kind == Kind.OTHER && getKind() != kind)
                return false;
            String n = cn + kind.extension;

            DEBUG.P("name="+name+" n="+n);
            DEBUG.P("f.getCanonicalFile()="+f.getCanonicalFile());
            DEBUG.P("f.getCanonicalFile().getName()="+f.getCanonicalFile().getName());

            if (name.equals(n))
                return true;
            if (name.equalsIgnoreCase(n)) {
				/*
				test\enter\Package-Info.java:20: 软件包注释应在文件 package-info.java 中
				@PackageAnnotation
				^
				1 错误
				*/
                try {
                    // allow for Windows
                    return (f.getCanonicalFile().getName().equals(n));
                } catch (IOException e) {
                }
            }
            return false;

            //f.getCanonicalFile()会抛出IOException
            //DEBUG.P("f.getCanonicalFile()="+f.getCanonicalFile());
            }catch (IOException e) {//我加上的
                return false;
            }finally{//我加上的
            DEBUG.P(1,this,"isNameCompatible(2)");
            }
        }

        /** @deprecated see bug 6410637 */
        @Deprecated
        public String getPath() {
            return f.getPath();
        }

        public long getLastModified() {
            return f.lastModified();
        }

        public boolean delete() {
            return f.delete();
        }

        public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
            try {//我加上的
            DEBUG.P(this,"getCharContent(1)");
            DEBUG.P("ignoreEncodingErrors="+ignoreEncodingErrors);

            SoftReference<CharBuffer> r = contentCache.get(this);
            CharBuffer cb = (r == null ? null : r.get());
            if (cb == null) {
                InputStream in = new FileInputStream(f);
                try {
                    ByteBuffer bb = makeByteBuffer(in);
                    JavaFileObject prev = log.useSource(this);
                    try {
                        cb = decode(bb, ignoreEncodingErrors);
                    } finally {
                        log.useSource(prev);
                    }
                    byteBufferCache.put(bb); // save for next time
                    if (!ignoreEncodingErrors)
                        contentCache.put(this, new SoftReference<CharBuffer>(cb));
                } finally {
                    in.close();
                }
            }
            return cb;

            }finally{//我加上的
            DEBUG.P(0,this,"getCharContent(1)");
            }
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof RegularFileObject))
                return false;
            RegularFileObject o = (RegularFileObject) other;
            try {
                return f.equals(o.f)
                    || f.getCanonicalFile().equals(o.f.getCanonicalFile());
            } catch (IOException e) {
                return false;
            }
        }

        @Override
        public int hashCode() {
            return f.hashCode();
        }

        public URI toUri() {
            try {
                // Do no use File.toURI to avoid file system access
                String path = f.getAbsolutePath().replace(File.separatorChar, '/');
                return new URI("file://" + path).normalize();
            } catch (URISyntaxException ex) {
                return f.toURI();
            }
        }

    }


text:
[![Latest Release](https://img.shields.io/github/release/softlayer/sl-ember-components.svg)](https://github.com/softlayer/sl-ember-components/releases) ![Ember CLI version](https://img.shields.io/badge/ember%20cli-0.2.7-orange.svg) [![License](https://img.shields.io/npm/l/sl-ember-components.svg)](LICENSE.md) [![Downloads](https://img.shields.io/npm/dm/sl-ember-components.svg)](https://www.npmjs.com/package/sl-ember-components)

[![Dependencies](https://img.shields.io/david/softlayer/sl-ember-components.svg)](https://david-dm.org/softlayer/sl-ember-components) [![Dev Dependencies](https://img.shields.io/david/dev/softlayer/sl-ember-components.svg)](https://david-dm.org/softlayer/sl-ember-components#info=devDependencies)

[![Build Status](https://img.shields.io/travis/softlayer/sl-ember-components/develop.svg)](https://travis-ci.org/softlayer/sl-ember-components) [![Code Climate](https://img.shields.io/codeclimate/github/softlayer/sl-ember-components.svg)](https://codeclimate.com/github/softlayer/sl-ember-components)

To see which issues are currently being worked on or are scheduled to be worked on next, visit [https://huboard.com/softlayer/sl-ember-components/#/](https://huboard.com/softlayer/sl-ember-components/#/)

### Is currently in BETA

# What sl-ember-components is

A UI components library compatible with Ember.js

Examples and documentation on how to use each component can be viewed at http://softlayer.github.io/sl-ember-components/ which
is served from the *gh-pages* branch of this repository.

**Components**

* sl-alert
* sl-button
* sl-calendar
* sl-chart (only free for non-commercial use without a [Highcharts](http://shop.highsoft.com/faq/non-commercial#what-is-commercial-website) license)
* sl-checkbox
* sl-date-picker
* sl-date-range-picker
* sl-date-time
* sl-drop-button
* sl-drop-option
* sl-grid
* sl-input
* sl-loading-icon
* sl-menu
* sl-modal
* sl-pagination
* sl-panel
* sl-progress-bar
* sl-radio
* sl-radio-group
* sl-select
* sl-span
* sl-tab-pane
* sl-tab-panel
* sl-textarea
* sl-tooltip

**Mixins**

*sl-input-based*

Provides state properties for input element based components.

*sl-tooltip-enabled*

Provides Bootstrap tooltip functionality bindings, for both popovers and plain tooltips.

**Helpers**

*get-key*

arguments: objectKey string, pathKey string, context object

Lookup a value on an object in the current context with passed-in objectKey and pathKey strings.

*render-dynamic*

Call the render handlebars helper with a key value for the template name lookup (render requires a string argument).

**Utility Classes**

*sl-menu-key-adapter*

Provides an abstraction between the events the *sl-menu* component listens for and the ability to associate any keyboard shortcuts in your application to trigger them.

---

All of this functionality is provided through a combination of leveraging the best-of-breed of other component offerings as well as our own implementations when the existing offerings were deficient. Existing offerings that were leveraged include:

* [Twitter Bootstrap](http://getbootstrap.com/)
* [Bootstrap-Datepicker](http://bootstrap-datepicker.readthedocs.org/en/release/#)
* [Highcharts](http://www.highcharts.com/)
* [Select2](http://ivaynberg.github.io/select2/)
* [typeahead.js](https://twitter.github.io/typeahead.js/)

## LICENSE WARNING

While this library is MIT licensed not all of the third-party component libraries are. Specifically, Highcharts is only free for non-commercial use and requires a license for any other use. See
[this FAQ page](http://shop.highsoft.com/faq/non-commercial#what-is-commercial-website) for more information.

Other libraries that are not MIT licensed, though it should not pose a problem, are:

* [Select2](https://github.com/ivaynberg/select2/blob/master/LICENSE)
* [Bootstrap-Datepicker](https://github.com/eternicode/bootstrap-datepicker/blob/release/LICENSE)

# Supported browsers

See [http://softlayer.github.io/sl-ember-components/browsers.html](http://softlayer.github.io/sl-ember-components/browsers.html)

# Demo

## Live

[http://softlayer.github.io/sl-ember-components/#/demos](http://softlayer.github.io/sl-ember-components/#/demos)

## Development Environment

### Installation

* `git clone` this repository
* `npm install`
* `bower install`

### Running

* `ember server`
* View the demo at *http://localhost:4200*

For more information on using ember-cli, visit [http://www.ember-cli.com/](http://www.ember-cli.com/).

### Documentation

* `ember ember-cli-jsoc` or `npm run docs` (shortcut setup in this repo)
* Visit *http://localhost:4200/docs*

# How to use this addon in your application

    ember install sl-ember-components
    npm install --save-dev ember-cli-less

Modify `Brocfile.js` file to add:

```
app.import({
    development : 'bower_components/bootstrap/dist/js/bootstrap.js',
    production  : 'bower_components/bootstrap/dist/js/bootstrap.min.js'
});
```

Create `app/styles/app.less` file. Then add to it:

```
@import 'sl-ember-components';
```

## Examples and documentation on how to use each component

Examples and documentation on how to use each component can be viewed at http://softlayer.github.io/sl-ember-components

# Versioning
Employs [Semantic Versioning 2.0.0](http://semver.org/)

# Contribution
[See CONTRIBUTING.md](https://github.com/softlayer/sl-ember-components/blob/master/CONTRIBUTING.md)

# Copyright and License
sl-ember-components and its source files are Copyright © 2014-2015 [SoftLayer Technologies, Inc.](http://www.softlayer.com/)
The software is [MIT Licensed](https://github.com/softlayer/sl-ember-components/blob/master/LICENSE.md)

sl-ember-components leverages several third-party libraries which are not all MIT licensed. Specifically, Highcharts is only
free for non-commercial use and requires a license for any other use. See
[this FAQ page](http://shop.highsoft.com/faq/non-commercial#what-is-commercial-website) for more information.

Other libraries that are not MIT licensed, though it should not pose a problem, are:

* [Select2](https://github.com/ivaynberg/select2/blob/master/LICENSE)
* [Bootstrap-Datepicker](https://github.com/eternicode/bootstrap-datepicker/blob/release/LICENSE)

# Warranty
This software is provided "as is" and without any express or implied warranties, including, without limitation, the
implied warranties of merchantability and fitness for a particular purpose.


text:
anchor: marcstats
title: MARCStats
start_date: 2009
end_date: 2013
images:
  -
    file: marc/tv.png
    desc: The team rankings, displayed in a "10-foot" style television display.
  -
    file: marc/menu.png
    desc: The main menu, with administrative options available.
  -
    file: marc/teams.png
    desc: The team setup page, on which attending teams can be added, modified, or removed.
  -
    file: marc/matchedit.png
    desc: The match editor, in which the final result of game matches can be entered.
  -
    file: marc/events.png
    desc: The event setup page, on which competitions can be added, modified, or removed.
  -
    file: marc/games.png
    desc: The game editor, in which properties of game scoring can be manipulated.
  -
    file: marc/system.png
    desc: The system setup page, on which system-wide options can be specified.
  -
    file: marc/rankings.png
    desc: The public rankings page.
  -
    file: marc/matches.png
    desc: The public match results page.
type: Web Application
technologies: ["PHP", "MySQL", "JS", "HTML", "CSS"]
link: http://webapps.mtr.brandonjd.net/marcstats/
link_title: Visit mirror
order: 6
---
My former FIRST Robotics team held an off-season competition called the Michigan
Advanced Robotics Competition (MARC). MARCStats is an application that I
designed to provide real-time statistics for teams at this event and their
supporters back home. These statistics included team rankings, match scores,
and team details. Volunteers at the event could also use the application to take
attendance of teams, show alerts to attendees, and input match data in
real-time.

MARCStats includes a "television display" which can display rankings and match
results in a "10-foot" style format, much like that of a television sports
broadcast. This was shown on displays around the event venue to allow attendees
to easily check the current state of the game.

Since game rules—including ranking calculation—change every year,
MARCStats was to be designed to be able to calculate match results and rankings
dynamically based on an arbitrary game configuration.

Eventually I realized that MARCStats could never exactly match the rankings
generated by the offical scoring system at the event, due to the use of
randomization, and the manually input match results were not always reliable.
In 2013, the project was scrapped.


text:
/**
 * BUILT WITH ANGULAR JS
 * SCRUM CLIENT
 */

var Scrum = angular.module('Scrum', [
    'ngRoute',
    'ScrumControllers',
    'ScrumServices',
    'ScrumFilters',
    'ui.bootstrap',
    'ui.sortable'
]);

Scrum.run(function ($rootScope, $location) {
    $rootScope.location = $location;
});

Scrum.config(['$routeProvider',
    function ($routeProvider) {
        $routeProvider.
            when('/', {
                templateUrl: 'dashboard.html',
                controller: 'dashboardController'
            }).
            otherwise({
                redirectTo: '/'
            });
    }]);


text:
<?php use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class InsertTextTranslations extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return  void
	 */
	public function up()
	{
		$migration_helper = App::make('\Neonbug\Common\Helpers\MigrationHelper');
		$migration_helper->insertTranslations(__DIR__ . '/translations.text/');
	}

	/**
	 * Reverse the migrations.
	 *
	 * @return  void
	 */
	public function down()
	{
	}

}


text:
<?php

namespace Magento\Customer\Block\Adminhtml;

use Magento\Customer\Api\AccountManagementInterface;
use Magento\Customer\Api\CustomerRepositoryInterface;
use Magento\Customer\Controller\RegistryConstants;

/**
 * Customer edit block
 */
class Edit extends \Magento\Backend\Block\Widget\Form\Container
{
    /**
     * Core registry
     *
     * @var \Magento\Framework\Registry
     */
    protected $_coreRegistry = null;

    /**
     * @var AccountManagementInterface
     */
    protected $customerAccountManagement;

    /**
     * @var CustomerRepositoryInterface
     */
    protected $customerRepository;

    /**
     * Customer view helper
     *
     * @var \Magento\Customer\Helper\View
     */
    protected $_viewHelper;

    /**
     * Constructor
     *
     * @param \Magento\Backend\Block\Widget\Context $context
     * @param \Magento\Framework\Registry $registry
     * @param AccountManagementInterface $customerAccountManagement
     * @param CustomerRepositoryInterface $customerRepository
     * @param \Magento\Customer\Helper\View $viewHelper
     * @param array $data
     */
    public function __construct(
        \Magento\Backend\Block\Widget\Context $context,
        \Magento\Framework\Registry $registry,
        AccountManagementInterface $customerAccountManagement,
        CustomerRepositoryInterface $customerRepository,
        \Magento\Customer\Helper\View $viewHelper,
        array $data = []
    ) {
        $this->_coreRegistry = $registry;
        $this->customerAccountManagement = $customerAccountManagement;
        $this->customerRepository = $customerRepository;
        $this->_viewHelper = $viewHelper;
        parent::__construct($context, $data);
    }

    /**
     * @return void
     */
    protected function _construct()
    {
        $this->_objectId = 'id';
        $this->_controller = 'adminhtml';
        $this->_blockGroup = 'Magento_Customer';

        $customerId = $this->getCustomerId();

        if ($customerId && $this->_authorization->isAllowed('Magento_Sales::create')) {
            $this->buttonList->add(
                'order',
                [
                    'label' => __('Create Order'),
                    'onclick' => 'setLocation(\'' . $this->getCreateOrderUrl() . '\')',
                    'class' => 'add'
                ],
                0
            );
        }

        parent::_construct();

        $this->buttonList->update('save', 'label', __('Save Customer'));
        $this->buttonList->update('delete', 'label', __('Delete Customer'));

        if ($customerId && $this->customerAccountManagement->isReadonly($customerId)) {
            $this->buttonList->remove('save');
            $this->buttonList->remove('reset');
        }

        if (!$customerId || $this->customerAccountManagement->isReadonly($customerId)) {
            $this->buttonList->remove('delete');
        }

        if ($customerId) {
            $url = $this->getUrl('customer/index/resetPassword', ['customer_id' => $customerId]);
            $this->buttonList->add(
                'reset_password',
                [
                    'label' => __('Reset Password'),
                    'onclick' => 'setLocation(\'' . $url . '\')',
                    'class' => 'reset reset-password'
                ],
                0
            );
        }

        if ($customerId) {
            $url = $this->getUrl('customer/customer/invalidateToken', ['customer_id' => $customerId]);
            $deleteConfirmMsg = __("Are you sure you want to revoke the customer\'s tokens?");
            $this->buttonList->add(
                'invalidate_token',
                [
                    'label' => __('Force Sign-In'),
                    'onclick' => 'deleteConfirm(\'' . $deleteConfirmMsg . '\', \'' . $url . '\')',
                    'class' => 'invalidate-token'
                ],
                10
            );
        }
    }

    /**
     * Retrieve the Url for creating an order.
     *
     * @return string
     */
    public function getCreateOrderUrl()
    {
        return $this->getUrl('sales/order_create/start', ['customer_id' => $this->getCustomerId()]);
    }

    /**
     * Return the customer Id.
     *
     * @return int|null
     */
    public function getCustomerId()
    {
        $customerId = $this->_coreRegistry->registry(RegistryConstants::CURRENT_CUSTOMER_ID);
        return $customerId;
    }

    /**
     * Retrieve the header text, either the name of an existing customer or 'New Customer'.
     *
     * @return \Magento\Framework\Phrase|string
     */
    public function getHeaderText()
    {
        $customerId = $this->getCustomerId();
        if ($customerId) {
            $customerData = $this->customerRepository->getById($customerId);
            return $this->escapeHtml($this->_viewHelper->getCustomerName($customerData));
        } else {
            return __('New Customer');
        }
    }

    /**
     * Prepare form Html. Add block for configurable product modification interface.
     *
     * @return string
     */
    public function getFormHtml()
    {
        $html = parent::getFormHtml();
        $html .= $this->getLayout()->createBlock(
            'Magento\Catalog\Block\Adminhtml\Product\Composite\Configure'
        )->toHtml();
        return $html;
    }

    /**
     * Retrieve customer validation Url.
     *
     * @return string
     */
    public function getValidationUrl()
    {
        return $this->getUrl('customer/*/validate', ['_current' => true]);
    }

    /**
     * Prepare the layout.
     *
     * @return $this
     */
    protected function _prepareLayout()
    {
        $customerId = $this->getCustomerId();
        if (!$customerId || !$this->customerAccountManagement->isReadonly($customerId)) {
            $this->buttonList->add(
                'save_and_continue',
                [
                    'label' => __('Save and Continue Edit'),
                    'class' => 'save',
                    'data_attribute' => [
                        'mage-init' => [
                            'button' => ['event' => 'saveAndContinueEdit', 'target' => '#edit_form'],
                        ],
                    ]
                ],
                10
            );
        }

        return parent::_prepareLayout();
    }

    /**
     * Retrieve the save and continue edit Url.
     *
     * @return string
     */
    protected function _getSaveAndContinueUrl()
    {
        return $this->getUrl(
            'customer/index/save',
            ['_current' => true, 'back' => 'edit', 'tab' => '{{tab_id}}']
        );
    }
}


text:
FROM --platform=$BUILDPLATFORM cgr.dev/chainguard/go:latest as build
LABEL maintainer="Will Norris <will@willnorris.com>"

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

COPY . .

ARG TARGETOS
ARG TARGETARCH
RUN CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -v ./cmd/imageproxy

FROM cgr.dev/chainguard/static:latest

COPY --from=build /app/imageproxy /app/imageproxy

CMD ["-addr", "0.0.0.0:8080"]
ENTRYPOINT ["/app/imageproxy"]

EXPOSE 8080


text:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PickUpItemTimed: MonoBehaviour {

    [SerializeField] private Item item;
	[SerializeField] private int TimeGoGrab = 2;

	private void Start()
	{
		Invoke("GetTheItem", TimeGoGrab);
	}

    public void GetTheItem()
    {
        Inventory.instance.AddItem(item);
        Destroy(this.gameObject);
    }
}


text:
package com.amazonaws.services.storagegateway.model.transform;

import javax.annotation.Generated;

import com.amazonaws.SdkClientException;
import com.amazonaws.services.storagegateway.model.*;

import com.amazonaws.protocol.*;
import com.amazonaws.annotation.SdkInternalApi;

/**
 * UpdateSMBSecurityStrategyRequestMarshaller
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
@SdkInternalApi
public class UpdateSMBSecurityStrategyRequestMarshaller {

    private static final MarshallingInfo<String> GATEWAYARN_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("GatewayARN").build();
    private static final MarshallingInfo<String> SMBSECURITYSTRATEGY_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("SMBSecurityStrategy").build();

    private static final UpdateSMBSecurityStrategyRequestMarshaller instance = new UpdateSMBSecurityStrategyRequestMarshaller();

    public static UpdateSMBSecurityStrategyRequestMarshaller getInstance() {
        return instance;
    }

    /**
     * Marshall the given parameter object.
     */
    public void marshall(UpdateSMBSecurityStrategyRequest updateSMBSecurityStrategyRequest, ProtocolMarshaller protocolMarshaller) {

        if (updateSMBSecurityStrategyRequest == null) {
            throw new SdkClientException("Invalid argument passed to marshall(...)");
        }

        try {
            protocolMarshaller.marshall(updateSMBSecurityStrategyRequest.getGatewayARN(), GATEWAYARN_BINDING);
            protocolMarshaller.marshall(updateSMBSecurityStrategyRequest.getSMBSecurityStrategy(), SMBSECURITYSTRATEGY_BINDING);
        } catch (Exception e) {
            throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
        }
    }

}


text:
@import url("jquery.ui.core.css");
@import url("jquery.ui.resizable.css");
@import url("jquery.ui.selectable.css");
@import url("jquery.ui.accordion.css");
@import url("jquery.ui.autocomplete.css");
@import url("jquery.ui.button.css");
@import url("jquery.ui.dialog.css");
@import url("jquery.ui.slider.css");
@import url("jquery.ui.tabs.css");
@import url("jquery.ui.datepicker.css");
@import url("jquery.ui.progressbar.css");
@import url("addon/jquery.ui.timepicker.css");
@import url("addon/jquery.ui.spinner.css");


text:
/***********************************************
* ZQAppEvent.cpp
*
* @author: zyq
* @date: 17/2/22
* @Description:
*
***********************************************/
#include "ZQAppEvent.h"

using namespace zq;

ZQAppEvent* ZQAppEvent::getInstance()
{
    static ZQAppEvent instance;
    return &instance;
}

void ZQAppEvent::applicationDidFinishLaunching()
{
    this->emit("applicationDidFinishLaunching");
}

void ZQAppEvent::applicationWillEnterForeground()
{
    this->emit("applicationWillEnterForeground");
}

void ZQAppEvent::applicationDidEnterBackground()
{
    this->emit("applicationDidEnterBackground");
}

void ZQAppEvent::applicationDidReceiveMemoryWarning()
{
    this->emit("applicationDidReceiveMemoryWarning");
}

void ZQAppEvent::androidShouldReset()
{
    this->emit("androidShouldReset");
}


text:
<!DOCTYPE html>

    <meta content='text/html; charset=utf-8' http-equiv='Content-Type' />
    <meta content='en' name='lang' />
    <meta name='viewport' content='width=device-width' />
    <meta name="description" content="Information about Saumon (Coho / Saumon Argenté US/Canadien)." />
    <meta name="keywords" content="fish, guide, sustainability, Saumon (Coho / Saumon Argenté US/Canadien)" />
    <title>Saumon (Coho / Saumon Argenté US/Canadien)</title>
    <link href='../css/screen.css' media='all' rel='stylesheet' type='text/css' />

    <link href='i/favicon.png' id='favicon' rel='icon' type='image/png' />
    <link href='i/touch.png' id='touch' rel='apple-touch-icon' />
    <link href='i/retina.png' id='retina' rel='apple-touch-icon' sizes='114x114' />

        Saumon (Coho / Saumon Argenté US/Canadien)

The Monterey Bay Aquarium lists farmed US Coho as a Best Choice and wild Canadian Coho as a good alternative.

      ← Back to list of fishes

Sources:

Monterey Bay Aquarium

Marine Conservation Society

FDA Mercury Table

      The MCS lists wild-caught salmon as a 5, and rates most farmed salmon as a 3. The Monterey Bay Aquarium lists the same farmed salmon as Avoid, making it not recommended, but does specifically mention Alaskan and Coho as good options.


text:
.class Lcom/android/net/IProxyPortListener$Stub$Proxy;
.super Ljava/lang/Object;
.source "IProxyPortListener.java"

# interfaces
.implements Lcom/android/net/IProxyPortListener;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/android/net/IProxyPortListener$Stub;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0xa
    name = "Proxy"
.end annotation

# instance fields
.field private mRemote:Landroid/os/IBinder;

# direct methods
.method constructor <init>(Landroid/os/IBinder;)V
    .locals 0
    .param p1, "remote"    # Landroid/os/IBinder;

    .prologue
    .line 61
    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    .line 62
    iput-object p1, p0, Lcom/android/net/IProxyPortListener$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    .line 63
    return-void
.end method

# virtual methods
.method public asBinder()Landroid/os/IBinder;
    .locals 1

    .prologue
    .line 66
    iget-object v0, p0, Lcom/android/net/IProxyPortListener$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    return-object v0
.end method

.method public getInterfaceDescriptor()Ljava/lang/String;
    .locals 1

    .prologue
    .line 70
    const-string v0, "com.android.net.IProxyPortListener"

    return-object v0
.end method

.method public setProxyPort(I)V
    .locals 5
    .param p1, "port"    # I
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    .line 74
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 76
    .local v0, "_data":Landroid/os/Parcel;
    :try_start_0
    const-string v1, "com.android.net.IProxyPortListener"

    invoke-virtual {v0, v1}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 77
    invoke-virtual {v0, p1}, Landroid/os/Parcel;->writeInt(I)V

    .line 78
    iget-object v1, p0, Lcom/android/net/IProxyPortListener$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v2, 0x1

    const/4 v3, 0x0

    const/4 v4, 0x1

    invoke-interface {v1, v2, v0, v3, v4}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 81
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 83
    return-void

    .line 81
    :catchall_0
    move-exception v1

    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    throw v1
.end method