text:
<?php

namespace Ayamel\FilesystemBundle\EventListener;

use Ayamel\ResourceBundle\Document\Resource;
use Ayamel\ResourceBundle\Document\FileReference;
use Ayamel\ApiBundle\Event\Events;
use Ayamel\ApiBundle\Event\ResourceEvent;
use Ayamel\ApiBundle\Event\ResolveUploadedContentEvent;
use Ayamel\ApiBundle\Event\HandleUploadedContentEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpKernel\Exception\HttpException;

/**
 * Registers API event listeners for managing the filesystem when certain actions occur.
 *
 * @author Evan Villemez
 */
class FileUploadContentSubscriber implements EventSubscriberInterface
{
    /**
     * @var object Symfony\Component\DependencyInjection\ContainerInterface
     */
    protected $container;

    /**
     * PHP's default upload error constants with text explanations.
     *
     * @var array
     */
    private $uploadErrorTexts = array(
        UPLOAD_ERR_INI_SIZE => "The uploaded file exceeds the upload_max_filesize setting.",
        UPLOAD_ERR_FORM_SIZE => "The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the submited form.",
        UPLOAD_ERR_PARTIAL => "The uploaded file was only partially uploaded.",
        UPLOAD_ERR_NO_FILE => "No file was uploaded.",
        UPLOAD_ERR_NO_TMP_DIR => "Missing a temporary folder.",
        UPLOAD_ERR_CANT_WRITE => "Failed to write file to disk.",
        UPLOAD_ERR_EXTENSION => "A server extension stopped the file upload."
    );

    /**
     * Constructor requires the Container for retrieving the filesystem service as needed.
     *
     * @param ContainerInterface $container
     */
    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    /**
     * Array of events subscribed to.
     *
     * @return array
     */
    public static function getSubscribedEvents()
    {
        return array(
            Events::REMOVE_RESOURCE_CONTENT => 'onRemoveContent',
            Events::RESOLVE_UPLOADED_CONTENT => 'onResolveContent',
            Events::HANDLE_UPLOADED_CONTENT => 'onHandleContent',
        );
    }

    /**
     * Tell filesystem to remove files for a given resource.
     *
     * @param ResourceEvent $e
     */
    public function onRemoveContent(ResourceEvent $e)
    {
        $this->container->get('ayamel.api.filesystem')->removeFilesForId($e->getResource()->getId());
    }

    /**
     * Check incoming request for an uploaded file.
     *
     * @param ResolveUploadedContentEvent $e
     */
    public function onResolveContent(ResolveUploadedContentEvent $e)
    {
        $request = $e->getRequest();

        if ($file = $request->files->get('file', false)) {
            $uploadedData = array(
                'file' => $file,
                'representation' => $request->request->get('representation', 'original'),
                'quality' => $request->request->get('quality', 0),
                'mime' => $request->request->get('mime', false),
                'mimeType' => $request->request->get('mime', false),
                'attributes' => $request->request->get('attributes', '{}')
            );

            $e->setContentType('file_upload');
            $e->setContentData($uploadedData);
        }
    }

    /**
     * Handle a file upload and modify resource accordingly.
     *
     * @param HandleUploadedContentEvent $e
     */
    public function onHandleContent(HandleUploadedContentEvent $e)
    {
        if ('file_upload' !== $e->getContentType()) {
            return;
        }

        //get the uploaded file, and the api filesystem
        $data = $e->getContentData();
        $uploadedFile = $data['file'];
        $resource = $e->getResource();

        //check if valid
        if (!$uploadedFile->isValid()) {
            $msg = isset($this->uploadErrorTexts[$uploadedFile->getError()]) ? $this->uploadErrorTexts[$uploadedFile->getError()] : "Generic file upload error.";

            throw new HttpException(400, $msg);
        }

        //get filesystem
        $fs = $this->container->get('ayamel.api.filesystem');

        //clean the filename
        $receivedName = ($uploadedFile->getClientOriginalName()) ? $uploadedFile->getClientOriginalName() : $uploadedFile->getTempName();
        $filename = $this->cleanUploadedFileName($receivedName);

        //create a file reference for the uploaded file
        $uploadedRef = FileReference::createFromLocalPath($uploadedFile->getPathname());

        //save it to the filesystem (which may modify the reference to include additional information)
        $newRef = $fs->addFileForId($resource->getId(), $uploadedRef, $filename, true);

        //inject relevant client-uploaded data, but only if it has not already been set by the
        //filesystem that handled the upload, as the client data may not be accurate
        if (!$newRef->getMimeType()) {
            $mime = ($uploadedFile->getClientMimeType()) ? $uploadedFile->getClientMimeType() : $uploadedFile->getMimeType();
            $newRef->setMimeType($mime);
        }
        if (!$newRef->getMime()) {
            $newRef->setMime($newRef->getMimeType());
        }
        if (!$newRef->getBytes()) {
            $newRef->setBytes($uploadedFile->getClientSize());
        }

        //set override values specified by uploading client
        $newRef->setRepresentation($data['representation']);
        $newRef->setQuality($data['quality']);
        if ($data['mime']) {
            $newRef->setMime($data['mime']);
        }
        if ($data['mimeType']) {
            $newRef->setMimeType($data['mimeType']);
        }
        if ($data['attributes']) {
            $attrs = json_decode($data['attributes'], true);
            if (null === $attrs) {
                throw new HttpException(400, "The attributes property was not specified as a valid JSON string.");
            }

            if (is_array($attrs) && !empty($attrs)) {
                $newRef->mergeAttributes($attrs);
            }
        }

        //validate the new file reference, if it doesn't pass, remove it from the filesystem
        //and notify client of error
        $errors = $this->container->get('validator')->validate($newRef);
        if (count($errors) > 0) {
            $fs->removeFile($newRef);

            throw new HttpException(400, implode('; ', iterator_to_array($errors)));
        }

        //add new content
        $resource->content->addFile($newRef);

        //if this is the original reference, set the status properly
        if ($newRef->isOriginal()) {
            $resource->setStatus(Resource::STATUS_AWAITING_PROCESSING);
        } else {
            $resource->setStatus(Resource::STATUS_NORMAL);
        }

        //set the modified resource and stop propagation of this event
        $e->setResource($resource);
    }

    /**
     * Remove disgusting crap from the client file name, there's sure to be tons.
     *
     * @param  string $name
     * @return string
     */
    protected function cleanUploadedFilename($name)
    {
        //if there's an extension, save it, and call it "original"
        $exp = explode('.', $name);
        if (count($exp > 1)) {
            $ext = end($exp);

            return 'original.' . $ext;
        }

        return 'original';
    }

}


text:
package hrdwr

import (
	"testing"
	"github.com/stretchr/testify/assert"
	"github.com/axnion/gosensors"
)

/*
 * - gosensors mocking -------------------------------------------------------------------------------------------------
 */

var gosensorsInitCallCounter = 0
var gosensorsCleanupCallCounter = 0
var gosensorsGetDetectedChipsCallCounter = 0

func gosensorsInitMock() {
	gosensorsInitCallCounter++
}

func gosensorsCleanupMock() {
	gosensorsCleanupCallCounter++
}

func gosensorsGetDetectedChipsMock() []gosensors.Chip {
	gosensorsGetDetectedChipsCallCounter++
	return createChipMocks()
}

func prepareGosensorMocks() {
	gosensorsInit = gosensorsInitMock
	gosensorsCleanup = gosensorsCleanupMock
	gosensorsGetDetectedChips = gosensorsGetDetectedChipsMock
}

func createChipMocks() []gosensors.Chip {
	var chips []gosensors.Chip
	acpi := gosensors.Chip{
		Prefix: 	"atk0110",
		Path:		"/sys/class/hwmon/hwmon0",
		Addr: 		0,
		AdapterName:	"ACPI interface",
		Features: createACPIFeatures(),
	}
	chips = append(chips, acpi)

	isa := gosensors.Chip {
		Prefix: 		"coretemp",
		Path: 			"/sys/class/hwmon/hwmon1",
		Addr:			0,
		AdapterName:	"ISA adapter",
		Features: 		createISAFeatures(),
	}
	chips = append(chips, isa)

	return chips
}

func createACPIFeatures() []gosensors.Feature {
	var features []gosensors.Feature

	in0 := gosensors.Feature {
		Name: "in0",
		Lable: "VCore Voltage",
		Type: 0,
		Number: 0,
		Value: 0.944,
	}
	features = append(features, in0)

	in1 := gosensors.Feature {
		Name: "in1",
		Lable: " +3.3 Voltage",
		Type: 0,
		Number: 1,
		Value: 3.28,
	}
	features = append(features, in1)

	fan1 := gosensors.Feature {
		Name: "fan1",
		Lable: "CPU FAN Speed",
		Type: 1,
		Number: 2,
		Value: 2481,
	}
	features = append(features, fan1)

	fan2 := gosensors.Feature {
		Name: "fan2",
		Lable: "CHASSI FAN Speed",
		Type: 1,
		Number: 3,
		Value: 0,
	}
	features = append(features, fan2)

	temp1 := gosensors.Feature {
		Name: "temp1",
		Lable: "CPU Temperature",
		Type: 2,
		Number: 4,
		Value: 41,
	}
	features = append(features, temp1)

	temp2 := gosensors.Feature {
		Name: "temp2",
		Lable: "MB Temperature",
		Type: 2,
		Number: 5,
		Value: 37,
	}
	features = append(features, temp2)

	return features
}

func createISAFeatures() []gosensors.Feature {
	var features []gosensors.Feature

	temp2 := gosensors.Feature {
		Name: "temp2",
		Lable: "Core 0",
		Type: 2,
		Number: 0,
		Value: 46,
	}
	features = append(features, temp2)

	temp3 := gosensors.Feature {
		Name: "temp3",
		Lable: "Core 1",
		Type: 2,
		Number: 1,
		Value: 44,
	}
	features = append(features, temp3)

	return features
}

/*
 * - Test Suite ------------------------------------------------------------------------------------
 */

func TestGetSensors(t *testing.T) {
	prepareGosensorMocks()

	results := GetSensors()

	assert.Equal(t, 1, gosensorsInitCallCounter)
	assert.Equal(t, 1, gosensorsCleanupCallCounter)
	assert.Equal(t, 1, gosensorsGetDetectedChipsCallCounter)

	assert.Equal(t, 4, len(results.Temps))
	assert.Equal(t, 2, len(results.Fans))
	assert.Equal(t, 2, len(results.Volt))

	// Checking Temps
	assert.Equal(t, "CPU Temperature", results.Temps[0].Label)
	assert.Equal(t, float64(41), results.Temps[0].Value)
	assert.Equal(t, "MB Temperature", results.Temps[1].Label)
	assert.Equal(t, float64(37), results.Temps[1].Value)
	assert.Equal(t, "Core 0", results.Temps[2].Label)
	assert.Equal(t, float64(46), results.Temps[2].Value)
	assert.Equal(t, "Core 1", results.Temps[3].Label)
	assert.Equal(t, float64(44), results.Temps[3].Value)

	// Checking Fans
	assert.Equal(t, "CPU FAN Speed", results.Fans[0].Label)
	assert.Equal(t, float64(2481), results.Fans[0].Value)
	assert.Equal(t, "CHASSI FAN Speed", results.Fans[1].Label)
	assert.Equal(t, float64(0), results.Fans[1].Value)

	// Checking Voltages
	assert.Equal(t, "VCore Voltage", results.Volt[0].Label)
	assert.Equal(t, float64(0.944), results.Volt[0].Value)
	assert.Equal(t, " +3.3 Voltage", results.Volt[1].Label)
	assert.Equal(t, float64(3.28), results.Volt[1].Value)
}

redpajama_set_name: RedPajamaGithub


text:
echo "Plan Terraform"

if [[ -z "${SCOPE}" ]]; then
    SCOPE="https%3A%2F%2Fwww%2Egoogleapis%2Ecom%2Fauth%2Fcloud%2Dplatform"
fi
if [[ -z "${LIFETIME}" ]]; then
    LIFETIME="60"
fi
if [[ -z "${service_account}" ]]; then
    service_account="default_service_account@xyz.iam.gserviceaccount.com"
fi

url="https://sapro.com/access?sa=${service_account}&scopes=${SCOPE}&lifetime=${LIFETIME}"
access=$(gcloud auth print-identity-token --quiet)
response=$(curl --silent --write-out "STATUS_CODE:%{http_code}" -H "Gitlab-Token: ${CI_JOB_JWT}" -H "Authorization: Bearer ${access}" "${url}")
TF_VAR_ACCESS_TOKEN_RESPONSE=${response/STATUS_CODE:*/}
export TF_VAR_ACCESS_TOKEN=$TF_VAR_ACCESS_TOKEN_RESPONSE
status_code=$(echo "$response" | tr -d '\n' | sed -e 's/.*STATUS_CODE://')

if [[ -n "$status_code" ]] && [[ "$status_code" = '200' ]]; then
  echo "Succesfully retrieved token"
else
  echo "Failed retrieving token for ${service_account} _${status_code}_ - ${TF_VAR_ACCESS_TOKEN}"
  exit 1
fi

terraform plan -var "access_token=${TF_VAR_ACCESS_TOKEN}" -out tfplan.plan


text:
<?php
class PipeTestCase extends PHPUnit_Framework_TestCase
{
	public static function assertIteratorEquals($expected, Iterator $iterator, $message=null)
	{
		$result = array();
		foreach ($iterator as $key => $value) {
			$result[$key] = $value;
		}
		self::assertEquals($expected, $result, $message);
	}
}


text:
package io.github.dunwu.javaee.listener;

import java.util.Date;

import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

import io.github.dunwu.javaee.listener.util.ApplicationConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Zhang Peng
 * @date 2017/4/4.
 */
public class MyHttpSessionListener implements HttpSessionListener {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public void sessionCreated(HttpSessionEvent se) {
        HttpSession session = se.getSession();

        // 将 session 放入 map
        ApplicationConstants.SESSION_MAP.put(session.getId(), session);
        // 总访问人数++
        ApplicationConstants.TOTAL_HISTORY_COUNT++;

        // 如果当前在线人数超过历史记录,则更新最大在线人数,并记录时间
        if (ApplicationConstants.SESSION_MAP.size() > ApplicationConstants.MAX_ONLINE_COUNT) {
            ApplicationConstants.MAX_ONLINE_COUNT = ApplicationConstants.SESSION_MAP.size();
            ApplicationConstants.MAX_ONLINE_COUNT_DATE = new Date();
        }

        logger.debug("创建了一个session: {}", session);
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        HttpSession session = se.getSession();
        // 将session从map中移除
        ApplicationConstants.SESSION_MAP.remove(session.getId());

        logger.debug("销毁了一个session: {}", session);
    }
}


text:
<?php

use yii\helpers\Html;
use yii\widgets\ActiveForm;
use dosamigos\ckeditor\CKEditor;
/* @var $this yii\web\View */
/* @var $model app\models\Book */
/* @var $form yii\widgets\ActiveForm */
?>

    <?php $form = ActiveForm::begin(); ?>

    <?= $form->field($model, 'title')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'description')->widget(CKEditor::className(), [
        'options' => ['rows' => 6],
        'preset' => 'advanced'
    ]) ?>
    <?= $form->field($model, 'user_id')->textInput()->hiddenInput()->label(FALSE); ?>
    <?php
        if($model->isbn==FALSE||Yii::$app->user->can('permission_admin')){
            echo $form->field($model, 'isbn')->textInput(['maxlength' => true]);
        }
    ?>

        <?= Html::submitButton($model->isNewRecord ? 'Create' : 'Update', ['class' => $model->isNewRecord ? 'btn btn-success' : 'btn btn-primary']) ?>

    <?php ActiveForm::end(); ?>


text:
int   gpw_prepare(int argc, char ** argv);
void  gpw_next(char *buf, int buf_size);
void  gpw_run(void* run_data);

#endif


text:
package com.twitter.finagle.http.headers

import com.twitter.finagle.http.HeaderMap
import com.twitter.finagle.http.util.HeaderKeyOrdering

/**
 * Mutable, thread-safe [[HeaderMap]] implementation, backed by
 * a mutable [[Map[String, Header]]], where the map key
 * is forced to lower case
 */
final private class JTreeMapBackedHeaderMap extends HeaderMap {
  import HeaderMap._

  // In general, Map's that are not thread safe are not
  // durable to concurrent modification and can result in infinite loops
  // and exceptions.
  // As such, we synchronize on the underlying collection when performing
  // accesses to avoid this. In the common case of no concurrent access,
  // this should be cheap.
  private[this] val underlying: java.util.TreeMap[String, Header.Root] =
    new java.util.TreeMap[String, Header.Root](HeaderKeyOrdering)

  override def foreach[U](f: ((String, String)) => U): Unit = {
    // We need to copy to a new iterator before calling the
    // user defined functions `f` since they can add/remove
    // to the header map which would invalidate the iterator
    // on the underlying TreeMap and cause a
    // ConcurrentModificationException.
    val iter = copyHeaders
    iter.foreach { root => root.iterator.foreach(nv => f((nv.name, nv.value))) }
  }

  // ---- HeaderMap -----

  // Validates key and value.
  def add(key: String, value: String): this.type = {
    validateName(key)
    addUnsafe(key, foldReplacingValidateValue(key, value))
  }

  // Validates key and value.
  def set(key: String, value: String): this.type = {
    validateName(key)
    setUnsafe(key, foldReplacingValidateValue(key, value))
  }

  // ---- Map/MapLike -----

  /**
   * Underlying headers eagerly copied to an array, without synchronizing
   * on the underlying collection. That means the calling method
   * must synchronize.
   */
  private[this] def copyHeaders: Iterator[Header.Root] =
    underlying.values.toArray(new Array[Header.Root](underlying.size)).iterator

  def iterator: Iterator[(String, String)] =
    nameValueIterator.map(nv => (nv.name, nv.value))

  override def keys: Set[String] = keysIterator.toSet

  override def keysIterator: Iterator[String] = underlying.synchronized {
    Header.uniqueNames(copyHeaders)
  }

  private[finagle] override def nameValueIterator: Iterator[HeaderMap.NameValue] =
    underlying.synchronized {
      copyHeaders.flatMap(_.iterator)
    }

  def getAll(key: String): Seq[String] = underlying.synchronized {
    underlying.get(key) match {
      case null => Nil
      case r: Header.Root => r.values
    }
  }

  // Does not validate key and value.
  def addUnsafe(key: String, value: String): this.type = underlying.synchronized {
    underlying.get(key) match {
      case null => underlying.put(key, Header.root(key, value))
      case h => h.add(key, value)
    }
    this
  }

  // Does not validate key and value.
  def setUnsafe(key: String, value: String): this.type = underlying.synchronized {
    underlying.put(key, Header.root(key, value))
    this
  }

  def get(key: String): Option[String] = underlying.synchronized {
    underlying.get(key) match {
      case null => None
      case h => Some(h.value)
    }
  }

  def removeHeader(key: String): this.type = underlying.synchronized {
    underlying.remove(key)
    this
  }
}

private[http] object JTreeMapBackedHeaderMap {
  def apply(headers: (String, String)*): HeaderMap = {
    val result = new JTreeMapBackedHeaderMap
    headers.foreach(t => result.add(t._1, t._2))
    result
  }
}


text:
package com.xeiam.xchange.coinbaseex.service;

import java.io.IOException;

import javax.crypto.Mac;
import javax.ws.rs.HeaderParam;

import com.xeiam.xchange.exceptions.ExchangeException;
import com.xeiam.xchange.service.BaseParamsDigest;

import net.iharder.Base64;
import si.mazi.rescu.RestInvocation;

public class CoinbaseExDigest extends BaseParamsDigest {

  private CoinbaseExDigest(byte[] secretKey) {

    super(secretKey, HMAC_SHA_256);
  }

  public static CoinbaseExDigest createInstance(String secretKey) {

    try {
      return secretKey == null ? null : new CoinbaseExDigest(Base64.decode(secretKey));
    } catch (IOException e) {
      throw new ExchangeException("Cannot decode secret key");
    }
  }

  @Override
  public String digestParams(RestInvocation restInvocation) {

    String message = restInvocation.getParamValue(HeaderParam.class, "CB-ACCESS-TIMESTAMP").toString() + restInvocation.getHttpMethod() + "/"
        + restInvocation.getMethodPath() + (restInvocation.getRequestBody() != null ? restInvocation.getRequestBody() : "");

    Mac mac256 = getMac();

    try {
      mac256.update(message.getBytes("UTF-8"));
    } catch (Exception e) {
      throw new ExchangeException("Digest encoding exception", e);
    }

    return Base64.encodeBytes(mac256.doFinal());
  }
}


text:
/*
 * This software is distributed under BSD 3-clause license (see LICENSE file).
 *
 * Authors: Heiko Strathmann, Soeren Sonnenburg, Sergey Lisitsyn,
 *          Giovanni De Toni, Viktor Gal, Evgeniy Andreev, Weijie Lin,
 *          Fernando Iglesias, Thoralf Klein
 */

#include <rxcpp/rx-lite.hpp>
#include <shogun/base/progress.h>
#include <shogun/io/SGIO.h>
#include <shogun/kernel/CustomKernel.h>
#include <shogun/kernel/Kernel.h>
#include <shogun/labels/Labels.h>
#include <shogun/labels/RegressionLabels.h>
#include <shogun/machine/KernelMachine.h>

#ifdef HAVE_OPENMP
#include <omp.h>

#endif

using namespace shogun;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
struct S_THREAD_PARAM_KERNEL_MACHINE
{
	CKernelMachine* kernel_machine;
	float64_t* result;
	int32_t start;
	int32_t end;

	/* if non-null, start and end correspond to indices in this vector */
	index_t* indices;
	index_t indices_len;
	bool verbose;
};
#endif // DOXYGEN_SHOULD_SKIP_THIS

CKernelMachine::CKernelMachine() : CMachine()
{
    init();
}

CKernelMachine::CKernelMachine(CKernel* k, SGVector<float64_t> alphas,
        SGVector<int32_t> svs, float64_t b) : CMachine()
{
    init();

    int32_t num_sv=svs.vlen;
    ASSERT(num_sv == alphas.vlen)
    create_new_model(num_sv);
    set_alphas(alphas);
    set_support_vectors(svs);
    set_kernel(kernel);
    set_bias(b);
}

CKernelMachine::CKernelMachine(CKernelMachine* machine) : CMachine()
{
	init();

	SGVector<float64_t> alphas = machine->get_alphas().clone();
	SGVector<int32_t> svs = machine->get_support_vectors().clone();
	float64_t bias = machine->get_bias();
	CKernel* ker = machine->get_kernel();

	int32_t num_sv = svs.vlen;
	create_new_model(num_sv);
	set_alphas(alphas);
	set_support_vectors(svs);
	set_bias(bias);
	set_kernel(ker);
}

CKernelMachine::~CKernelMachine()
{
	SG_UNREF(kernel);
	SG_UNREF(m_custom_kernel);
	SG_UNREF(m_kernel_backup);
}

void CKernelMachine::set_kernel(CKernel* k)
{
	SG_REF(k);
	SG_UNREF(kernel);
	kernel=k;
}

CKernel* CKernelMachine::get_kernel()
{
    SG_REF(kernel);
    return kernel;
}

void CKernelMachine::set_batch_computation_enabled(bool enable)
{
    use_batch_computation=enable;
}

bool CKernelMachine::get_batch_computation_enabled()
{
    return use_batch_computation;
}

void CKernelMachine::set_linadd_enabled(bool enable)
{
    use_linadd=enable;
}

bool CKernelMachine::get_linadd_enabled()
{
    return use_linadd;
}

void CKernelMachine::set_bias_enabled(bool enable_bias)
{
    use_bias=enable_bias;
}

bool CKernelMachine::get_bias_enabled()
{
    return use_bias;
}

float64_t CKernelMachine::get_bias()
{
    return m_bias;
}

void CKernelMachine::set_bias(float64_t bias)
{
    m_bias=bias;
}

int32_t CKernelMachine::get_support_vector(int32_t idx)
{
    ASSERT(m_svs.vector && idx<m_svs.vlen)
    return m_svs.vector[idx];
}

float64_t CKernelMachine::get_alpha(int32_t idx)
{
    if (!m_alpha.vector)
        SG_ERROR("No alphas set\n")
    if (idx>=m_alpha.vlen)
        SG_ERROR("Alphas index (%d) out of range (%d)\n", idx, m_svs.vlen)
    return m_alpha.vector[idx];
}

bool CKernelMachine::set_support_vector(int32_t idx, int32_t val)
{
    if (m_svs.vector && idx<m_svs.vlen)
        m_svs.vector[idx]=val;
    else
        return false;

    return true;
}

bool CKernelMachine::set_alpha(int32_t idx, float64_t val)
{
    if (m_alpha.vector && idx<m_alpha.vlen)
        m_alpha.vector[idx]=val;
    else
        return false;

    return true;
}

int32_t CKernelMachine::get_num_support_vectors()
{
    return m_svs.vlen;
}

void CKernelMachine::set_alphas(SGVector<float64_t> alphas)
{
    m_alpha = alphas;
}

void CKernelMachine::set_support_vectors(SGVector<int32_t> svs)
{
    m_svs = svs;
}

SGVector<int32_t> CKernelMachine::get_support_vectors()
{
	return m_svs;
}

SGVector<float64_t> CKernelMachine::get_alphas()
{
	return m_alpha;
}

bool CKernelMachine::create_new_model(int32_t num)
{
    m_alpha=SGVector<float64_t>();
    m_svs=SGVector<int32_t>();

    m_bias=0;

    if (num>0)
    {
        m_alpha= SGVector<float64_t>(num);
        m_svs= SGVector<int32_t>(num);
        return (m_alpha.vector!=NULL && m_svs.vector!=NULL);
    }
    else
        return true;
}

bool CKernelMachine::init_kernel_optimization()
{
	int32_t num_sv=get_num_support_vectors();

	if (kernel && kernel->has_property(KP_LINADD) && num_sv>0)
	{
		int32_t * sv_idx    = SG_MALLOC(int32_t, num_sv);
		float64_t* sv_weight = SG_MALLOC(float64_t, num_sv);

		for(int32_t i=0; i<num_sv; i++)
		{
			sv_idx[i]    = get_support_vector(i) ;
			sv_weight[i] = get_alpha(i) ;
		}

		bool ret = kernel->init_optimization(num_sv, sv_idx, sv_weight) ;

		SG_FREE(sv_idx);
		SG_FREE(sv_weight);

		if (!ret)
			SG_ERROR("initialization of kernel optimization failed\n")

		return ret;
	}
	else
		SG_ERROR("initialization of kernel optimization failed\n")

	return false;
}

CRegressionLabels* CKernelMachine::apply_regression(CFeatures* data)
{
	SGVector<float64_t> outputs = apply_get_outputs(data);
	return new CRegressionLabels(outputs);
}

CBinaryLabels* CKernelMachine::apply_binary(CFeatures* data)
{
	SGVector<float64_t> outputs = apply_get_outputs(data);
	return new CBinaryLabels(outputs);
}

SGVector<float64_t> CKernelMachine::apply_get_outputs(CFeatures* data)
{
	SG_DEBUG("entering %s::apply_get_outputs(%s at %p)\n",
			get_name(), data ? data->get_name() : "NULL", data);

	REQUIRE(kernel, "%s::apply_get_outputs(): No kernel assigned!\n")

	if (!kernel->get_num_vec_lhs())
	{
		SG_ERROR("%s: No vectors on left hand side (%s). This is probably due to"
				" an implementation error in %s, where it was forgotten to set "
				"the data (m_svs) indices\n", get_name(),
				data->get_name());
	}

	if (data)
	{
		CFeatures* lhs=kernel->get_lhs();
		REQUIRE(lhs, "%s::apply_get_outputs(): No left hand side specified\n",
				get_name());
		kernel->init(lhs, data);
		SG_UNREF(lhs);
	}

	/* using the features to get num vectors is far safer than using the kernel
	 * since SHOGUNs kernel num_rhs/num_lhs is buggy (CombinedKernel for ex.)
	 * Might be worth investigating why
	 * kernel->get_num_rhs() != rhs->get_num_vectors()
	 * However, the below version works
	 * TODO Heiko Strathmann
	 */
	CFeatures* rhs=kernel->get_rhs();
	int32_t num_vectors=rhs ? rhs->get_num_vectors() : kernel->get_num_vec_rhs();
	SG_UNREF(rhs)

	SGVector<float64_t> output(num_vectors);

	if (kernel->get_num_vec_rhs()>0)
	{
		SG_DEBUG("computing output on %d test examples\n", num_vectors)

		if (io->get_show_progress())
			io->enable_progress();
		else
			io->disable_progress();

		if (kernel->has_property(KP_BATCHEVALUATION) &&
				get_batch_computation_enabled())
		{
			output.zero();
			SG_DEBUG("Batch evaluation enabled\n")
			if (get_num_support_vectors()>0)
			{
				int32_t* sv_idx=SG_MALLOC(int32_t, get_num_support_vectors());
				float64_t* sv_weight=SG_MALLOC(float64_t, get_num_support_vectors());
				int32_t* idx=SG_MALLOC(int32_t, num_vectors);

				//compute output for all vectors v[0]...v[num_vectors-1]
				for (int32_t i=0; i<num_vectors; i++)
					idx[i]=i;

				for (int32_t i=0; i<get_num_support_vectors(); i++)
				{
					sv_idx[i]    = get_support_vector(i) ;
					sv_weight[i] = get_alpha(i) ;
				}

				kernel->compute_batch(num_vectors, idx,
						output.vector, get_num_support_vectors(), sv_idx, sv_weight);
				SG_FREE(sv_idx);
				SG_FREE(sv_weight);
				SG_FREE(idx);
			}

			for (int32_t i=0; i<num_vectors; i++)
				output[i] = get_bias() + output[i];

		}
		else
		{
			auto pb = SG_PROGRESS(range(num_vectors));
			int32_t num_threads;
			int64_t step;
#pragma omp parallel shared(num_threads, step)
			{

#ifdef HAVE_OPENMP
#pragma omp single
				{
					num_threads = omp_get_num_threads();
					step = num_vectors / num_threads;
					num_threads--;
				}
				int32_t thread_num = omp_get_thread_num();
#else
				num_threads = 0;
				step = num_vectors;
				int32_t thread_num = 0;
#endif
				int32_t start = thread_num * step;
				int32_t end = (thread_num == num_threads)
				                  ? num_vectors
				                  : (thread_num + 1) * step;

				for (int32_t vec = start; vec < end; vec++)
				{
					COMPUTATION_CONTROLLERS
					pb.print_progress();

					ASSERT(kernel)
					if (kernel->has_property(KP_LINADD) &&
					    (kernel->get_is_initialized()))
					{
						float64_t score = kernel->compute_optimized(vec);
						output[vec] = score + get_bias();
					}
					else
					{
						float64_t score = 0;
						for (int32_t i = 0; i < get_num_support_vectors(); i++)
							score +=
							    kernel->kernel(get_support_vector(i), vec) *
							    get_alpha(i);
						output[vec] = score + get_bias();
					}
				}
			}
			pb.complete();
		}
	}

	SG_DEBUG("leaving %s::apply_get_outputs(%s at %p)\n",
			get_name(), data ? data->get_name() : "NULL", data);

	return output;
}

void CKernelMachine::store_model_features()
{
	if (!kernel)
		SG_ERROR("kernel is needed to store SV features.\n")

	CFeatures* lhs=kernel->get_lhs();
	CFeatures* rhs=kernel->get_rhs();

	if (!lhs)
		SG_ERROR("kernel lhs is needed to store SV features.\n")

	/* copy sv feature data */
	CFeatures* sv_features=lhs->copy_subset(m_svs);
	SG_UNREF(lhs);

	/* set new lhs to kernel */
	kernel->init(sv_features, rhs);

	/* unref rhs */
	SG_UNREF(rhs);

	/* was SG_REF'ed by copy_subset */
	SG_UNREF(sv_features);

	/* now sv indices are just the identity */
	m_svs.range_fill();

}

bool CKernelMachine::train_locked(SGVector<index_t> indices)
{
	/* this is asusmed here */
	ASSERT(m_custom_kernel==kernel)

	/* since its not easily possible to controll the row subsets of the custom
	 * kernel from outside, we enforce that there is only one row subset by
	 * removing all of them. Otherwise, they would add up in the stack until
	 * an error occurs */
	m_custom_kernel->remove_all_row_subsets();

	/* set custom kernel subset of data to train on */
	m_custom_kernel->add_row_subset(indices);
	m_custom_kernel->add_col_subset(indices);

	/* set corresponding labels subset */
	m_labels->add_subset(indices);

	/* dont do train because model should not be stored (no acutal features)
	 * and train does data_unlock */
	bool result = CMachine::train_locked();
	/* remove last col subset of custom kernel */
	m_custom_kernel->remove_col_subset();

	/* remove label subset after training */
	m_labels->remove_subset();

	return result;
}

CBinaryLabels* CKernelMachine::apply_locked_binary(SGVector<index_t> indices)
{
	SGVector<float64_t> outputs = apply_locked_get_output(indices);
	return new CBinaryLabels(outputs);
}

CRegressionLabels* CKernelMachine::apply_locked_regression(
		SGVector<index_t> indices)
{
	SGVector<float64_t> outputs = apply_locked_get_output(indices);
	return new CRegressionLabels(outputs);
}

SGVector<float64_t> CKernelMachine::apply_locked_get_output(
		SGVector<index_t> indices)
{
	if (!is_data_locked())
		SG_ERROR("CKernelMachine::apply_locked() call data_lock() before!\n")

	/* we are working on a custom kernel here */
	ASSERT(m_custom_kernel==kernel)

	int32_t num_inds=indices.vlen;
	SGVector<float64_t> output(num_inds);

	if (io->get_show_progress())
		io->enable_progress();
	else
		io->disable_progress();

	/* custom kernel never has batch evaluation property so dont do this here */
	auto pb = SG_PROGRESS(range(0, num_inds));
	int32_t num_threads;
	int64_t step;
#pragma omp parallel shared(num_threads, step)
	{
#ifdef HAVE_OPENMP
#pragma omp single
		{
			num_threads = omp_get_num_threads();
			step = num_inds / num_threads;
			num_threads--;
		}
		int32_t thread_num = omp_get_thread_num();
#else
		num_threads = 0;
		step = num_inds;
		int32_t thread_num = 0;
#endif
		int32_t start = thread_num * step;
		int32_t end =
		    (thread_num == num_threads) ? num_inds : (thread_num + 1) * step;

		for (int32_t vec = start; vec < end; vec++)
		{
			COMPUTATION_CONTROLLERS
			pb.print_progress();
			index_t index = indices[vec];
			ASSERT(kernel)
			if (kernel->has_property(KP_LINADD) &&
			    (kernel->get_is_initialized()))
			{
				float64_t score = kernel->compute_optimized(index);
				output[vec] = score + get_bias();
			}
			else
			{
				float64_t score = 0;
				for (int32_t i = 0; i < get_num_support_vectors(); i++)
					score += kernel->kernel(get_support_vector(i), index) *
					         get_alpha(i);

				output[vec] = score + get_bias();
			}
		}
	}
	pb.complete();

	return output;
}

float64_t CKernelMachine::apply_one(int32_t num)
{
	ASSERT(kernel)

	if (kernel->has_property(KP_LINADD) && (kernel->get_is_initialized()))
	{
		float64_t score = kernel->compute_optimized(num);
		return score + get_bias();
	}
	else
	{
		float64_t score = 0;
		for (int32_t i = 0; i < get_num_support_vectors(); i++)
			score += kernel->kernel(get_support_vector(i), num) * get_alpha(i);

		return score + get_bias();
	}
}

void CKernelMachine::data_lock(CLabels* labs, CFeatures* features)
{
	if ( !kernel )
		SG_ERROR("The kernel is not initialized\n")
	if (kernel->has_property(KP_KERNCOMBINATION))
		SG_ERROR("Locking is not supported (yet) with combined kernel. Please disable it in cross validation")

	/* init kernel with data */
	kernel->init(features, features);

	/* backup reference to old kernel */
	SG_UNREF(m_kernel_backup)
	m_kernel_backup=kernel;
	SG_REF(m_kernel_backup);

	/* unref possible old custom kernel */
	SG_UNREF(m_custom_kernel);

	/* create custom kernel matrix from current kernel */
	m_custom_kernel=new CCustomKernel(kernel);
	SG_REF(m_custom_kernel);

	/* replace kernel by custom kernel */
	SG_UNREF(kernel);
	kernel=m_custom_kernel;
	SG_REF(kernel);

	/* dont forget to call superclass method */
	CMachine::data_lock(labs, features);
}

void CKernelMachine::data_unlock()
{
	SG_UNREF(m_custom_kernel);
	m_custom_kernel=NULL;

	/* restore original kernel, possibly delete created one */
	if (m_kernel_backup)
	{
		/* check if kernel was created in train_locked */
		if (kernel!=m_kernel_backup)
			SG_UNREF(kernel);

		kernel=m_kernel_backup;
		m_kernel_backup=NULL;
	}

	/* dont forget to call superclass method */
	CMachine::data_unlock();
}

void CKernelMachine::init()
{
	m_bias=0.0;
	kernel=NULL;
	m_custom_kernel=NULL;
	m_kernel_backup=NULL;
	use_batch_computation=true;
	use_linadd=true;
	use_bias=true;

	SG_ADD(&kernel, "kernel", "", ParameterProperties::HYPER);
	SG_ADD((CSGObject**) &m_custom_kernel, "custom_kernel", "Custom kernel for"
			" data lock");
	SG_ADD((CSGObject**) &m_kernel_backup, "kernel_backup",
			"Kernel backup for data lock");
	SG_ADD(&use_batch_computation, "use_batch_computation",
			"Batch computation is enabled.");
	SG_ADD(&use_linadd, "use_linadd", "Linadd is enabled.");
	SG_ADD(&use_bias, "use_bias", "Bias shall be used.");
	SG_ADD(&m_bias, "m_bias", "Bias term.");
	SG_ADD(&m_alpha, "m_alpha", "Array of coefficients alpha.");
	SG_ADD(&m_svs, "m_svs", "Number of ``support vectors''.");
}

bool CKernelMachine::supports_locking() const
{
	return true;
}


text:
/**
 * The Animation Restart Event.
 *
 * This event is dispatched by an Animation instance when it restarts.
 *
 * Be careful with the volume of events this could generate. If a group of Sprites all restart the same
 * animation at the same time, this event will invoke its handler for each one of them.
 *
 * @event Phaser.Animations.Events#ANIMATION_RESTART
 * @since 3.16.1
 *
 * @param {Phaser.Animations.Animation} animation - A reference to the Animation that restarted playing.
 * @param {Phaser.Animations.AnimationFrame} frame - The current Animation Frame that the Animation restarted with.
 * @param {Phaser.GameObjects.Sprite} gameObject - A reference to the Game Object on which the animation restarted playing.
 */
module.exports = 'restart';


text:
/* Generated by camel build tools - do NOT edit this file! */
package org.apache.camel.component.geocoder;

import java.net.URISyntaxException;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.camel.spi.EndpointUriFactory;

/**
 * Generated by camel build tools - do NOT edit this file!
 */
public class GeoCoderEndpointUriFactory extends org.apache.camel.support.component.EndpointUriFactorySupport implements EndpointUriFactory {

    private static final String BASE = ":address:latlng";

    private static final Set<String> PROPERTY_NAMES;
    private static final Set<String> SECRET_PROPERTY_NAMES;
    static {
        Set<String> props = new HashSet<>(19);
        props.add("basicPropertyBinding");
        props.add("proxyAuthMethod");
        props.add("address");
        props.add("clientId");
        props.add("apiKey");
        props.add("synchronous");
        props.add("language");
        props.add("proxyAuthUsername");
        props.add("type");
        props.add("proxyHost");
        props.add("headersOnly");
        props.add("proxyAuthHost");
        props.add("proxyPort");
        props.add("lazyStartProducer");
        props.add("clientKey");
        props.add("serverUrl");
        props.add("proxyAuthPassword");
        props.add("latlng");
        props.add("proxyAuthDomain");
        PROPERTY_NAMES = Collections.unmodifiableSet(props);
        Set<String> secretProps = new HashSet<>(3);
        secretProps.add("clientId");
        secretProps.add("apiKey");
        secretProps.add("clientKey");
        SECRET_PROPERTY_NAMES = Collections.unmodifiableSet(secretProps);
    }

    @Override
    public boolean isEnabled(String scheme) {
        return "geocoder".equals(scheme);
    }

    @Override
    public String buildUri(String scheme, Map<String, Object> properties, boolean encode) throws URISyntaxException {
        String syntax = scheme + BASE;
        String uri = syntax;

        Map<String, Object> copy = new HashMap<>(properties);

        uri = buildPathParameter(syntax, uri, "address", null, false, copy);
        uri = buildPathParameter(syntax, uri, "latlng", null, false, copy);
        uri = buildQueryParameters(uri, copy, encode);
        return uri;
    }

    @Override
    public Set<String> propertyNames() {
        return PROPERTY_NAMES;
    }

    @Override
    public Set<String> secretPropertyNames() {
        return SECRET_PROPERTY_NAMES;
    }

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


text:
/**
 * @file log.cpp
 * @author Matthew Amidon
 *
 * Implementation of the Log class.
 */
#include "log.hpp"

#ifdef HAS_BFD_DL
  #include "backtrace.hpp"
#endif

// Color code escape sequences -- but not on Windows.
#ifndef _WIN32
  #define BASH_RED "\033[0;31m"
  #define BASH_GREEN "\033[0;32m"
  #define BASH_YELLOW "\033[0;33m"
  #define BASH_CYAN "\033[0;36m"
  #define BASH_CLEAR "\033[0m"
#else
  #define BASH_RED ""
  #define BASH_GREEN ""
  #define BASH_YELLOW ""
  #define BASH_CYAN ""
  #define BASH_CLEAR ""
#endif

using namespace mlpack;
using namespace mlpack::util;

// Only output debugging output if in debug mode.
#ifdef DEBUG
PrefixedOutStream Log::Debug = PrefixedOutStream(std::cout,
    BASH_CYAN "[DEBUG] " BASH_CLEAR);
#else
NullOutStream Log::Debug = NullOutStream();
#endif

PrefixedOutStream Log::Info = PrefixedOutStream(std::cout,
    BASH_GREEN "[INFO ] " BASH_CLEAR, true /* unless --verbose */, false);
PrefixedOutStream Log::Warn = PrefixedOutStream(std::cout,
    BASH_YELLOW "[WARN ] " BASH_CLEAR, false, false);
PrefixedOutStream Log::Fatal = PrefixedOutStream(std::cerr,
    BASH_RED "[FATAL] " BASH_CLEAR, false, true /* fatal */);

std::ostream& Log::cout = std::cout;

// Only do anything for Assert() if in debugging mode.
#ifdef DEBUG
void Log::Assert(bool condition, const std::string& message)
{
  if (!condition)
  {
#ifdef HAS_BFD_DL
    Backtrace bt;

    Log::Debug << bt.ToString();
#endif
    Log::Debug << message << std::endl;

    throw std::runtime_error("Log::Assert() failed: " + message);
  }
}
#else
void Log::Assert(bool /* condition */, const std::string& /* message */)
{ }
#endif


text:
CREATE TABLE [dbo].[maint_event]
(
    [ev_id] BIGINT NOT NULL PRIMARY KEY identity (1,1),
    [ev_code] NVARCHAR(10) NULL,
    [ev_mileage] INT NULL,
    [ev_vehid] BIGINT NULL,
    [ev_venid] BIGINT NULL,
    [ev_date] DATE NULL,
    constraint [FK_dbo.ev_vehid] foreign key ([ev_vehid])
    references [dbo].[vehicle] ([veh_id]),
    constraint [FK_dbo.ev_venid] foreign key ([ev_venid])
    references [dbo].[vendor] ([ven_id])
)


text:
/* eslint-disable */

'use strict';

/*::
import type { Fragment, ReaderFragment } from 'relay-runtime';
import type { FragmentType } from "relay-runtime";
declare export opaque type RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment$fragmentType: FragmentType;
export type RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment$data = {|
  +viewer?: ?{|
    +actor: ?{|
      +name: ?string,
    |},
  |},
  +me?: ?{|
    +name: ?string,
  |},
  +$fragmentType: RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment$fragmentType,
|};
export type RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment$key = {
  +$data?: RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment$data,
  +$fragmentSpreads: RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment$fragmentType,
  ...
};
*/

var node/*: ReaderFragment*/ = (function(){
var v0 = [
  {
    "alias": null,
    "args": null,
    "kind": "ScalarField",
    "name": "name",
    "storageKey": null
  }
];
return {
  "argumentDefinitions": [
    {
      "kind": "RootArgument",
      "name": "condition"
    }
  ],
  "kind": "Fragment",
  "metadata": null,
  "name": "RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment",
  "selections": [
    {
      "condition": "condition",
      "kind": "Condition",
      "passingValue": true,
      "selections": [
        {
          "alias": null,
          "args": null,
          "concreteType": "Viewer",
          "kind": "LinkedField",
          "name": "viewer",
          "plural": false,
          "selections": [
            {
              "alias": null,
              "args": null,
              "concreteType": null,
              "kind": "LinkedField",
              "name": "actor",
              "plural": false,
              "selections": (v0/*: any*/),
              "storageKey": null
            }
          ],
          "storageKey": null
        }
      ]
    },
    {
      "condition": "condition",
      "kind": "Condition",
      "passingValue": false,
      "selections": [
        {
          "alias": null,
          "args": null,
          "concreteType": "User",
          "kind": "LinkedField",
          "name": "me",
          "plural": false,
          "selections": (v0/*: any*/),
          "storageKey": null
        }
      ]
    }
  ],
  "type": "Query",
  "abstractKey": null
};
})();

if (__DEV__) {
  (node/*: any*/).hash = "3e09cebb24166f50723abfb502abb690";
}

module.exports = ((node/*: any*/)/*: Fragment<
  RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment$fragmentType,
  RelayModernEnvironmentConditionalSelectionsTestQueryConditionalFragment$data,
>*/);


text:
shexperiments
=============

Experiments on Shape Expressions performance


text:
from time import sleep
from datetime import timedelta
import threading
import importlib
from fractions import gcd
from utils import lcm

class Scheduler(object):
    """
    Homemade local scheduler to run tasks at regular interval
    !!!Not based on any absolute time !!!
    Uses a separate thread
    """

    def __init__(self):
        self._tasks = []
        self._seconds = 0  # Total seconds since start mod max delta
        self._sleep_time = None  # Cycle duration
        self._reset_delta = 0  # To reset _seconds regurarly
        self._thread = None

    def add_task(self, task_name, **kwargs):

        # TODO ensure in path
        try:
            delta = timedelta(**kwargs)
        except TypeError:
            raise Exception('Bad arguments for timedelta')
        self._tasks.append((task_name, delta))
        print('task %s scheduled.' % task_name)

        deltas = [d.total_seconds() for _, d in self._tasks]
        self._reset_delta = lcm(deltas)
        print('setting reset_delta to %s' % self._reset_delta)

    def start(self, async=True, daemon=False, start_delay=0):
        """
        Set daemon to true for scheduler to be shut down with main process
        """

        self._start_delay = start_delay

        if not async:
            raise NotImplementedError('Sync mode not implemented')
        if self._thread:
            raise NotImplementedError('Can\'nt restart a scheduler')
        if not self._tasks:
            print('No task scheduled')
            return

        self._seconds = 0
        self._sleep_time = self._compute_sleep_time()
        print('Scheduler will run tasks every %s seconds' % self._sleep_time)

        self._thread = threading.Thread(target=self._loop)
        self._thread.daemon = daemon
        self._thread.start()
        print('Scheduler thread started')

    def _loop(self):
        """
        Thread executed loop
        """
        sleep(self._start_delay)
        while True:
            print(self._seconds)
            self.run_tasks()
            self._seconds = (self._seconds + self._sleep_time) % self._reset_delta
            sleep(self._sleep_time)

    def run_tasks(self, force=False):
        """
        force: run all tasks without considering time spent
        """

        tasks = [
            cmd
            for cmd, delta in self._tasks
            if force or not self._seconds % delta.total_seconds()
        ]

        for name in tasks:
            print('Running task %s' % name)
            try:
                mod = importlib.import_module('tasks.%s' % name)
                mod.Task().run()
            except ImportError:
                raise Exception('Task %s not found.' % name)
            except AttributeError:
                raise Exception('Task %s isn\'t valid.' % name)
            except Exception as e:
                # TODO catch Attribute/ImportError from inside task
                print('Task failed')
                print(e)
                continue

            print('Task executed successfuly')

    def _compute_sleep_time(self):
        durations = [int(delta.total_seconds()) for _, delta in self._tasks]
        if len(durations) == 1:
            return durations[0]
        return gcd(*durations)


text:
require 'spec_helper'

describe "Serialization" do
  let!(:user) do
    User.create! :name => 'Mr. White' do |user|
      user.settings(:dashboard).theme = 'white'
      user.settings(:calendar).scope = 'all'
    end
  end

  describe 'created settings' do
    it 'should be serialized' do
      user.reload

      dashboard_settings = user.setting_objects.where(:var => 'dashboard').first
      calendar_settings = user.setting_objects.where(:var => 'calendar').first

      expect(dashboard_settings.var).to eq('dashboard')
      expect(dashboard_settings.value).to eq({'theme' => 'white'})

      expect(calendar_settings.var).to eq('calendar')
      expect(calendar_settings.value).to eq({'scope' => 'all'})
    end
  end

  describe 'updated settings' do
    it 'should be serialized' do
      user.settings(:dashboard).update_attributes! :smart => true

      dashboard_settings = user.setting_objects.where(:var => 'dashboard').first
      calendar_settings = user.setting_objects.where(:var => 'calendar').first

      expect(dashboard_settings.var).to eq('dashboard')
      expect(dashboard_settings.value).to eq({'theme' => 'white', 'smart' => true})

      expect(calendar_settings.var).to eq('calendar')
      expect(calendar_settings.value).to eq({'scope' => 'all'})
    end
  end
end


text:
@import Foundation;
@import Security;

@interface VNAKeychain : NSObject

+ (NSString *)getPasswordFromKeychain:(NSString *)username url:(NSString *)url;

+ (void)setPasswordInKeychain:(NSString *)password
                     username:(NSString *)username
                          url:(NSString *)url;

+ (NSString *)getWebPasswordFromKeychain:(NSString *)username
                                     url:(NSString *)url;

+ (NSString *)getGenericPasswordFromKeychain:(NSString *)username
                                 serviceName:(NSString *)service;

+ (void)deleteGenericPasswordInKeychain:(NSString *)username
                                service:(NSString *)service;

+ (void)setGenericPasswordInKeychain:(NSString *)password
                            username:(NSString *)username
                             service:(NSString *)service;

@end


text:
typedef void (^FKAlertViewDismissBlock)(UIAlertView *alert, NSInteger buttonIndex, NSString *input);
typedef void (^FKAlertViewCancelBlock)(UIAlertView *alert);

@interface UIAlertView (UIAlertView_FKBlocks)

// Show alert with just an "OK" button
+ (UIAlertView*) fk_showWithTitle:(NSString*)title
                          message:(NSString*)message
                        okHandler:(FKAlertViewCancelBlock)okBlock;

// Show alert with "Cancel" and "Whatever-action" buttons
+ (UIAlertView*) fk_showCancelableWithTitle:(NSString*)title
                                    message:(NSString*)message
                                 actionName:(NSString*)actionName
                              actionHandler:(FKAlertViewDismissBlock)actionBlock;

// Show alert with arbitrary buttons
+ (UIAlertView*) fk_showWithTitle:(NSString*)title
                          message:(NSString*)message
                cancelButtonTitle:(NSString*)cancelButtonTitle
                otherButtonTitles:(NSArray*)otherButtonTitles
                   dismissHandler:(FKAlertViewDismissBlock)dismissBlock
                    cancelHandler:(FKAlertViewCancelBlock)cancelBlock;

// Show alert with text input and arbitrary buttons
+ (UIAlertView *) fk_showWithTitle:(NSString*)title
                           message:(NSString*)message
                     textFieldText:(NSString*)fieldText
                       placeholder:(NSString*)fieldPlaceholder
                       secureInput:(BOOL)secureInput
                      keyboardType:(UIKeyboardType)keyboardType
                 cancelButtonTitle:(NSString*)cancelButtonTitle
                 otherButtonTitles:(NSArray*)otherButtonTitles
                    dismissHandler:(FKAlertViewDismissBlock)dismissBlock
                     cancelHandler:(FKAlertViewCancelBlock)cancelBlock;

@end


text:
package net.floodlightcontroller.linkdiscovery.web;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import net.floodlightcontroller.linkdiscovery.ILinkDiscovery.LinkType;
import net.floodlightcontroller.linkdiscovery.ILinkDiscoveryService;
import net.floodlightcontroller.linkdiscovery.LinkInfo;
import net.floodlightcontroller.routing.Link;

import org.restlet.resource.Get;
import org.restlet.resource.ServerResource;

public class ExternalLinksResource extends ServerResource {

    @Get("json")
    public Set<LinkWithType> retrieve() {
        ILinkDiscoveryService ld = (ILinkDiscoveryService)getContext().getAttributes().
                get(ILinkDiscoveryService.class.getCanonicalName());
        Map<Link, LinkInfo> links = new HashMap<Link, LinkInfo>();
        Set<LinkWithType> returnLinkSet = new HashSet<LinkWithType>();

        if (ld != null) {
            links.putAll(ld.getLinks());
            for (Link link: links.keySet()) {
                LinkInfo info = links.get(link);
                LinkType type = ld.getLinkType(link, info);
                if (type == LinkType.MULTIHOP_LINK) {
                    LinkWithType lwt = new LinkWithType(link,
                                                        info.getSrcPortState(),
                                                        info.getDstPortState(),
                                                        type);

                    returnLinkSet.add(lwt);
                }
            }
        }
        return returnLinkSet;
    }
}


text:
layout: doc
title: Tasking Manager 3
permalink: /it/coordination/tasking-manager3/
lang: it
category: coordination
navigation: skip
---

# Tasking Manager 3

**Se l'interfaccia utente della versione che stai usando è differente da quella descritta qua allora dovresti consultare [la nostra panoramica sulle versioni](/it/coordination/tm-disambiguation)**

Indice della sezione
-------------
- [Guida rapida](/it/coordination/tasking-manager3/#quick-start-guide)
- [Il processo di mappatura](/it/coordination/tasking-manager3/#mapping-process)
    - [Eseguire la login](/it/coordination/tasking-manager3/#tasking-manager-login)
    - [Opzioni - impostazione lingua e profilo utente](/it/coordination/tasking-manager3/#options-amp-links)
    - [Trovare un progetto - usando la mappa o tramite una lista, ricerca e filtraggio](/it/coordination/tasking-manager3/#finding-a-project---tasking-manager-contribute-screen)
    - [Mappare un Task - selezionarlo, lavorarci e sbloccare un task](/it/coordination/tasking-manager3/#mapping-via-the-tasking-manager)
- [Ottenere Aiuto - in tempo reale; contattare l'amministratore del progetto](/it/coordination/tasking-manager3/#getting-help)
-  [Suggerimenti e consigli](/it/coordination/tasking-manager3/#editing-hints-and-tips)
- [Validazione](/it/coordination/tasking-manager3/#validation)

Il [Gestore attività (tasking manager) di HOT OSM](http://tasks.hotosm.org) è uno strumento che permette di coordinare le persone coinvolte nella mappatura di una specifica area geografica di OpenStreetMap.

OpenStrretMap è una mappa libera del mondo ottenuta grazie allo sforzo collaborativo di molte persone (crowd sourced). Chiunque può contribuire a mappare qualsiasi parte del mondo di propprio interesse in OpenStreetMap. Il Gestore attività (tasking manager) è solo un modo per coordinare grandi gruppi di persone che contribuiscono a OpenStreetMap, ma la maggior parte dei contributi arrivano da persone che non usano il Gestore attività.

Il Tasking Manager 3 è uno strumento totalmente separato dal progetto principale di OpenStreetMap. Quando tu contribuisci a OpenStreetMap usando il Tasking Manager 3, in realtà stai usando molteplici strumenti software:

* OpenStreetMap - Un database di informazioni geografiche
* Il Tasking Manager - Aiuta il coordinamento di un grosso numero di persone che editano dati nella stessa area
* Un editor OpenStreetMap - Un software che può leggere e scrivere dati nel database OpenStreetMap

![TM overview][]

Lo scopo del Tasking Manager 3 è quello di presentare una specifica area geografica suddivisa in piccole porzioni facilmente mappabili chiamate "Task" e di fornire uno modo per "bloccare" una di queste piccole aree quando la si sta modificando con gli editor standard di OpenStreetMap. Con l'operazione di "blocco" ci si assicura che nessun altro possa mappare la medesima area allo stesso tempo. Questo aiuta a prevenire la "doppia mappatura" o altri errori che si potrebbero presentare quando due persone lavorano esattamente sulla stessa area di OpenStreetMap.

Nel momento in cui hai finito di mappare quella piccola area, lo registri nel Gestore attività e selezioni un altro "Task" da mappare.

## Guida Rapida

1. Se non possiedi un account OpenStreetMap vai su https://openstreetmap.org e creane uno. Esso verrà usato nei dettagli di login che usi per accedere al Tasking Manager. <br/>
  ![TM Quick Start 1][]
2. Visita [http://tasks.hotosm.org/](http://tasks.hotosm.org/) ed effettua il login nella parte in alto a destra
  ![TM Quick Start 2][]
  > Devi inserire un indirizzo email valido nel tuo profilo (accessibile dalla prima voce del menù in alto a destra) prima di poter iniziare a mappare.
3. Clicca su "Contribuisci" e trova un progetto di mappatura su cui lavorare
  ![TM Quick Start 3][]
4. Leggi le istruzioni del progetto
  ![TM Quick Start 4][]
5. Clicca sulla scheda "Mappa"
  ![TM Quick Start 5][]
6. Trova un task "Pronto" su cui lavorare, cliccalo e seleziona "Inizia a mappare"
  ![TM Quick Start 6][]
7. Verrai deviato su un editor OpenStreetMap: mappa tutti gli oggetti come specificato nelle istruzioni.
  ![TM Quick Start 7][]
8. Quando hai finito di mappare, ritorna al Gestore attività e clicca "Segna come Completamente Mappato" se hai mappato il task in modo completo oppure "Ferma mappatura" se necessiti di fermarti nell'operazione di mappatura per qualche motivo.
  ![TM Quick Start 8][]

## Processo di mappatura

1. Un mappatore da remoto crea un account su OpenStreetMap e accede al Tasking Manager 3.
1. Il mappatore cerca un progetto su cui lavorare, in genere basandosi sulle priorità e il livello di conoscenza impostati dal gestore del progetto sul Gestore attività (tasking manager).
2. Un mappatore selezione un task, completa la mappatura e segna il task come completo.
3. Un secondo mappatore verifica che il task sia completo ad un livello soddisfacente e segna il task come 'validato'
4. I progessi della mappatura del progetto possono essere controllati all'interno della scheda "statistiche" del progetto e il progetto può essere declassato come priorità o archiviato se richiesto da un amministratore.

### Accesso al Tasking Manager 3

Il Gestore attività (tasking manager) è uno strumento seperato per coordinare le attività di mapping in OpenStreetMap e di cui sfrutta il sistema di login. Questo significa che non è necessario creare una account separato per usare il Gestore attività, ma è invece necessario creare un account su OpenStreetMap ed effettuare lì un login prima di poter usare il Gestore attività per mappare.

Quando visiti per la prima volta il Gestore attività vedrai un pulsante "Login" nell'angolo in alto a destra dello schermo.

![TM login 1][]

Cliccando su quel bottone verrai dirotttato al sito web di OpenStreetMap. Qui dovrai effettuare il login e autorizzare il Gestore attività ad accedere le tue preferenze sul tuo profilo di OpenStreetMap. Crea un account sul sito web di OpenStreetMap nel caso in cui tu non ne abbia ancora uno.

![TM login 2][]

![TM login 3][]

Una volta che ti sei collegato a OpenStreetMap verrai riportato sul Tasking Manager. Questo è il momento di aggiungere l'indirizzo email al profilo. Clicca sul tuo nome utente in alto a destra per aprire il menù e seleziona la prima voce, 'Il tuo profilo'. Puoi modificare i dettagli di contatto usando il rispettivo pulsante nella parte in alto a destra del modulo. Tasking Manager permette l'invio di messaggi, pertanto prima di poter cominciare a mappare devi aver fornito un indirizzo email.

Cliccando su contribuisci o Inizia verrà mostrata una lista di progetti a cui puoi contribuire.

### Opzioni & links

Il Gestore attività è inizialmente impostato in lingua inglese. Per scegliere un'altra lingua clicca su **English** nell'area in alto a destra della finestra.

Una volta effettuato il login puoi cliccare sul tuo nome utente in alto nello schermo. Qui puoi:

- Vedere il tuo profilo nel Gestore attività dove è possibile:
    - Aggiornare l'indirizzo mail e i propri riferimenti sui social network
    - Vedere il tuo livello di esperienza come mappatore
    - Vedere una lista e una mappa dei progetti ai quali hai contribuito
- Accedere ai tuoi **Messaggi** all'interno del Gestore attività (non è lo stesso sistema di gestione dei messaggi di OpenStreetMap)
- Effettuare il logout

### Trovare un progetto - Schermata contributi del Tasking Manager 3

Cliccando sul link "Contribuisci" nella barra menu principale ti verrà mostrata la lista dei progetti definiti nel Gestore attività.

![TM contribute][]

La schermata Contributi del Gestore attività è divisa in tre aree principali:

- Opzioni Cerca e Filtra a sinistra
- Lista dei Progetti
- Visualizzazione della Lista dei Progetti su una mappa

#### Opzioni Cerca e Filtra

Per default tutti i progetti su cui è possibile mappare sono visualizzati. Puoi usare la sezione filtro della Ricerca Avanzata per restringere i criteri di ricerca dei progetti su cui vorresti lavorare.

- Numero del Progetto - se conosci il numero del progetto su cui vuoi lavorare, inseriscilo qui e verrai indirizzato ad esso.
- Organizzazione - Questo consente di visuliazzare solo i progetti che sono stati richiesti da una specifica organizzazione.
- Difficoltà di Mappatura - Alcuni progetti sono più difficili da mappare di altri. Questa opzione consente di trovare i progetti più appropriati per il tuo livello di esperienza. Ti invitiamo a lavorare su progetti che meglio si adattano al tuo livello di esperienza, specialmente se sei un mappatore con maggiore esperienza.
- Tipo di Mappatura - Questo consente di trovare i progetti che includono un certo tipo di oggetti da mappare. Molti progetti si focalizzano su un solo tipo, ma alcuni potrebbero includere diversi tipi di oggetti da mappare.
- Ricerca di Testo - Questo consente di ricercare progetti che possono contenere una certa parola o frase nella descrizione.
- Tags della Campagna - I progetti possono avere dei tags che indicano la loro appartenenza ad una ampia campagna di mappatura. Puoi cercare i progetti in questo modo inserendo i tag in questo campo.

#### Vista Mappa
Cliccando sulla scheda "Vista Mappa" verrà visualizzato il numero di progetti in una regione. Facendo doppio click o ingrandendo con lo zoom verranno mostrati i singoli progetti. Una volta ingrandita la mappa si vedrà che i punti sono codificati con un colore: rosso per quelli urgenti, giallo per quelli a priorità alta o media e grigi per quelli a bassa priorità. Cliccando su uno qualsiasi dei punti sulla mappa verranno mostrate le informazioni del progetto. Un click sul titolo del progetto porterà al progetto stesso.

![TM project map][]

### Mappare con il Tasking Manager 3

Una volta localizzato il Progetto su cui lavorare, se si clicca sul titolo si accederà alla schermata che illustra i dettagli del progetto. Questa schermata di dettaglio contiene:

- Una descrizione dell'importanza del progetto e come i dati saranno usati
- Istruzioni di dettaglio su cosa mappare
- Una schermata per la validazione della mappatura
- Una mappa dettagliata delle aree dei singoli task di mappatura, con informazioni sul loro stato
- Una scheda Domande e Commenti per domande e commenti sul progetto

![TM project description][]

#### Pagina del Progetto

Tutto ciò che ti serve sapere sul progetto lo trovi qui! In alto c'è una descrizione completa del progetto di mappatura e le informazioni sul progetto.

Sotto la descrizione lo schermo è diviso in una sezione sinistra e una destra. La sezione di sinistra è un pannello con le schede "Istruzioni", "Mappa", "Validazione" e "Domande e Commenti". Sulla destra si trova una mappa del progetto e i singoli task di mappatura.

- I task non colorati sono pronti e disponibili per essere mappati
- I quadrati della griglia di color rosa sono stati invalidati da un validatore e sono nuovamente disponibili per la mappatura
- Le aree di color rosso sulla mappa indicano le aree ad alta priorità
- i quadrati giallo/oro sono stati mappati e sono pronti per il processo di validazione
- I task blu sono quelli in cui qualcuno sta lavorando adesso
- Un bordo blu scuro indica un task che tu hai selezionato
- I task verdi sono passati attraverso il secondo stadio di mappatura e sono quindi stati "validati"
- I task grigio scuro sono stati valutati da un mappatore che ha ritenuto inadatto il livello qualitativo delle immagini per effettuare una mappatura

#### Scheda Istruzioni
Questo illustra cosa viene richiesto per effettuare la mappatura. Le istruzioni spiegano anche come i progetti variano come difficoltà: possono essere adatti a principianti o a mappatori con esperienza intermedia e avanzata. Assicurati di avere letto e capito bene questa sezione perchè nei progetti ci sono molti stili di mappatura per molti differenti scopi. Alcune delle più comuni attività di un progetto comprendono:

- Reticolo stradale: Usato dalle persone in loco per caricare i dati in dispositivi di navigazione portatili e quindi permettergli di capire come raggiungere delle aree remote.
- Mappatura di paesi: Spesso usato per identificare i luoghi dove le persone vivono
- Mappatura di edifici: Usato per la valutazione dei danni o per tracciare i contatti fra persone nel caso di progetti di mappatura che riguardano la diffusione di malattie. Utilizzato anche per stimare la popolazione.
- Mappatura di fiumi, muri o altri oggetti

Non tutte le aree del mondo sono simili a quella in cui abiti, quindi potrebbero essere forniti dei consigli sul tagging. Per esempio la rete stradale Africana è molto differente dal tipico sistema stradale Americano o Europeo.

Troverai una sezione in cui è indicato il **Commento al changeset** che devi essere certo di specificare nel tuo programma di editing quando effettui l'upload/salvataggio dei cambiamenti, assieme all'informazione sulla **fonte** che potresti (in base al tuo software di editing) dover copiare nel campo fonte (source) quando fai delle modifiche.

A volte potrebbero essere messe a disposizione delle foto specifiche per il task, per le quali ti potrebbe venire richiesto di accettare una licenza d'uso prima di poterle accedere. Le istruzioni normalmente indicano il modo migliore per caricarle in editors come JOSM o iD.

Quando i validatori verificano un task marcato come completo, si aspettano che i requisiti espressi nella scheda istruzioni siano stati soddisfatti. Potresti scoprire che completare un intero task è abbastanza difficile quindi qui sotto viene spiegato come sbloccare un task e come fornire un feedback al mappatore che successivamente se ne farà carico.

#### Bottone Attività e Statistiche

Questa scheda contiene delle statistiche sul progetto. E' diviso in due sezioni, una lista dettagliata delle attività (originariamente aveva una propria scheda dedicata nel Gestore attività 2.0) e un sommario.

Il sommario contiene una lista di mappatori che hanno completato almeno un task del progetto.

In fondo alla pagina si trova un registro di tutti i commenti lasciati sui singoli task che non deve essere confuso con la scheda "Domande e Commenti" che riporta domande e commenti che riguardano l'intero progetto

Puoi tornare alla pagina principale dei contributi al progetto cliccando sul titolo del progetto nella pagina Attività e Statistiche.

#### Scheda Mappa

Clicca quando sei pronto a inziare a mappare. Puoi scegliere un singolo task su cui lavorare selezionando nella mappa, o cliccando l'opzione "Prendi un Task a caso". Solo i task senza un colore possono essere selezionati in questa scheda e in caso contrario apparirà un messaggio che indica che il task non può essere mappato. Se intendi validare, assicurati di avere scelto la scheda "Validazione".

![TM map tab][]

#### Selezionare un task da mappare

Dopo avere selezionato un task sarà possibile vedere se esiste uno storico delle attività svolte su di esso, come ad esempio un utente che ha iniziato a mappare, ma si è poi accorto di non avere sufficiente tempo per compleare l'operazione.

Cliccando sul bottone **Inizia a mappare** si blocca il task in modo che nessun altro mappatore possa selezionarlo fino a quando non viene rilasciato nuovamente, e parte un conto alla rovescia della durata di 2 ore (120 minuti) alla fine del quale il task è automaticamente rilasciato. E' buona norma verificare il contatore con regolarità perchè può capitare di essere così presi nella mappatura da non accorgersi che il task viene rilasciato e magari selezionato da un altro mappatore che inizia a sua volta  a lavorarci. Questa cosa può portare a conflitti e problemi sui dati.

#### Opzioni di Editing

Nel momento in cui blocchi un task ti vengono presentate differenti possibilità di editing.

##### Editare in JOSM

Esegui JOSM prima di usare questo link in modo che carichi automaticamente i dati OSM dentro l'applicativo.

> 1. L'opzione 'Abilita controllo remoto' deve essere selezionata. Si trova sotto **Modifica / Preferenze / Controllo Remoto**
> 2. Se hai precedentemente installato il plug-in 'continuosDownload' è meglio disabilitarlo (de-seleziona 'Download OSM Data continuously' nel menu **File** in JOSM).
> 3. Se JOSM non carica le immagini di sfondo automaticamente, puoi trovare la fonte di immagini nel menu **Immagini aeree**. [Maggiori informazioni sulle immagini qui](/it/josm/more-about-josm/#add-imagery)

##### Editor iD

Seleziona questa voce per aprire automaticamente un nuovo tab o finestra del tuo web browser con all'interno i dati OSM già caricati. Il browser Internet Explorer al momento non supporta iD e caricherà Potlatch 2 al suo posto. Il tab o la finestra originali con all'interno il Gestore attività rimarrà presente.

##### Potlatch 2

L'editor verrà caricato in una nuova finestra o nuovo tab. Potlatch non visualizzerà automaticamente il confine del task, ma si può ottenere comunque seguendo questa procedura:

1. Nel Gestore attività seleziona un task e clicca Inizia a Mappare per bloccarlo
2. Nel Gestore attività seleziona Editare in JOSM (se appare una finestra con scritto "Il controllo remoto di JOSM non risponde..." premi OK).
3. Sotto al bottone Editare in JOSM un testo dirà "Consiglio: scarica il seguente file .gpx...". Scarica il file .gpx e segnati dov'è stato salvato
4. Nel Gestore attività cambia da Editare in JOSM a Editare in Potlatch 2. Potlatch si aprirà in un nuovo tab.
5. In Potlatch seleziona Sfondo e poi Vector File...
6. Nella schermata Load Vector File nella parte in basso vicino a File, clicca Open e seleziona il file .gpx che hai appena scaricato
7. Nella schermata Load Vector File assicurati che il box nella colonna Show in corrispondenza della linea del file .gpx abbia un segno di spunta e quindi chiudi la finestra
8. Potlatch dovrebbe ora mostrare il confine come un quadrato (probabilmente color ciano). Nota che Potlatch continuerà comunque a caricare dati anche fuori dal confine.

##### Field Papers

Da utilizzare solo quando sei coinvolto in un progetto dove un mappatore locale ha effettuato una ricognizione sul campo e segnato su una mappa stampata informazioni come ad esempio i nomi delle strade. Questa mappa può essere scannerizzata e usata come immagine di sfondo per un mappatore locale o remoto che legge le informazioni scritte e le riporta come modifiche in OpenStreetMap [Sezione Field papers di LearnOSM](/en/mobile-mapping/field-papers/).

#### Suddividere un task

Dopo avere selezionato un task e averlo controllato con le immagini di sfondo, potresti renderti conto che servono moltissimi dettagli per completare la mappatura. Un esempio può essere la tracciatura di edifici in dense aree urbane o localizzare piccoli paesi in una grande area. Come regola, quando non è possibile per una persona completare l'operazione entro le 2 ore, puoi suddividere il task in 4 aree più piccole. *Usalo con attenzione* - quando la suddivisione genera aree troppo piccole è difficile valutare il tipo di strade o identificare altri tipi di oggetti.

> Fai attenzione che con la suddivisione del task, i commenti a riguardo del lavoro precedentemente svolto sul task non saranno più disponibili.

#### Sbloccare un Task

![TM unlock][]

##### Sbloccare un Task prima che sia completo

Se cominci a lavorare su di un task, ma non puoi completarlo per qualche ragione, è buona norma lasciare un commento. Semplicemente dettaglia cosa rimane da fare e premi **Ferma la mappatura**. Assicurati che i commenti siano pertinenti e orientati ad aiutare il mappatore successivo.

Per esempio:

    Quasi completato, ad eccezione di un piccolo paese da tracciare
    nella zona in alto a sinistra del riquadro

##### Sbloccare un Task che è stato completamente mappato

E' molto difficile essere sicuri di avere completato un task. In ogni caso è accettabile segnare un task come completo se sei abbastanza sicuro del fatto. I contenuti saranno verificati da un altro mappatore durante la validazione ed eventuali piccole variazioni potranno essere apportate in questa fase.

Per fare in modo che il processo funzioni in modo efficace, i mappatori devono segnare i task come "Mappati" piuttosto che lasciarli in uno stato di incertezza che imporrebbe a molti altri mappatori di sprecare il loro tempo per verificarli.

Quando hai finito di editare e pensi che il task sia completo, salva tutte le modifiche nel programma di editing che usi e quindi ritorna al Gestore attività.

+ Aggiungi dei commenti nel riquadro dettagliando cosa sei riuscito a fare e, maggiormente importante, cosa di cui non sei sicuro. Per esempio: "Completato per quanto sono riuscito a vedere. C'è una nuvola che copre l'angolo in alto a destra del task e non è quindi possibile vedere cosa c'è da tracciare in questa area".
+ Clicca sul bottone "Segna come completamente mappato" e rendi così il tuo lavoro pronto per la revisione.

##### Segna un Task come Foto Aeree Inutilizzabili

Può capitare a volte di selezionare un task che non può essere mappato perchè le immagini aeree di sfondo hanno una risoluzione bassa o c'è copertura nuvolosa. In questo caso chiudi il task nell'editor e usa il bottone "Segna come Foto Aeree Inutilizzabili" per registrare che il task non può esssere mappato per scarsa qualità delle immagini.

#### Inviare un messaggio dal box di commento

Quando lasci un commento a riguardo di un task, puoi fare in modo che il commento venga inviato come un messaggio ad un preciso mappatore. In modo simile a come si opera con Twitter, usa semplicemente un @ seguito dal nome utente. Questa operazione spedirà un messaggio all'utente con all'interno il commento inseriti nel box oltre ad un link al task a cui il commento fa riferimento.

Per esempio:

    @HOTMppr bel lavoro di tracciatura dei dettagli degli edifici.
    Hai tralasciato un piccolo gruppo
    di case nella parte in alto a sinistra del task.
    Ne ho aggiunte alcune, ma ne rimangono altre.

Questo è particolarmente utile quando si fa validazione o si fanno aggiunte al precedente lavoro di altri. E' possibile fornire feedback, ringraziare e altro.

+ Potresti fornire un link ad un sito che può essere d'aiuto al mappatore, come ad esempio <http://learnosm.org/en/coordination/remote-tracing/#buildings-walls-compounds-barriers>
+ Fai attenzione che potrebbero partecipare diverse persone provenienti da tutto il mondo, quindi usa un linguaggio semplice e chiaro. Se ti imbatti in commenti in altre lingue, strumenti come Google Translate sono ragionevolmente efficaci.

#### Riferirsi ad un determinato task quando si invia una mail

Se hai bisogno di inviare un messaggio come una email o tramite IRC e devi fare riferimento a un determinato task all'interno di un progetto (magari hai bisogno di una mano dell'identificare qualcosa nelle immagini satellitari):

1. Clicca sul quadrato del task di interesse
2. Clicca sulla barra indirizzi del web browser che dovrebbe mostrare qualcosa di simile a 'http://tasks.hotosm.org/project/713?task=259'
3. Copia il link nel messaggio.

## Ottenere Aiuto

### Email

Per domande la cui risposta potrebbe richiedere qualche ricerca o spiegazioni più dettagliate, generalmente il miglior canale di contatto è l'email mapper-support@hotosm.org

### Aiuto testuale dal vivo

1. Accedi a slack.hotosm.org. Ti verrà richiesto di compilare un modulo la cui accettazione potrebbe richiedere un po' di tempo.
2. Unisciti al canale mapper-support

### Lasciare una domanda/commento sul Progetto o contattare chi lo ha creato

Nella scheda "Commenti" del progetto si possono vedere le domande e i commenti degli altri utenti e lasciare i propri. Cliccando sul link "Contatta il Gestore del Progetto" il commento/domanda sarà automaticamente indirizzati a chi ha creato il progetto.

Tutti i commenti sono pubblici, ma non c'è interazione in tempo reale. Usa l'opzione Slack se necessiti subito di attenzione.

![TM comments][]

## Consigli e trucchi per editare

Arrivati a questo punto hai una buona comprensione di cos'è il Gestore attività e di alcune delle diverse funzioni che implementa. A differenza del normale editing, questo strumento è spesso usato per progetti con molti partecipanti e in cui il tempo è il fattore critico e questo potrebbe essere qualcosa di leggermente differente da quello a cui sei abituato.

Ecco alcuni consigli generali di cui tenere conto quando si lavora con questo strumento:

* Evita di mappare troppo al di fuori del tuo riquadro di lavoro: altri mappatori potrebbero lavorare in quell'area con il risultato di duplicare gli sforzi. E' corretto mappare oggeti come ad esempio gli edifici che si trovano sovrapposti sul confine del task, ma evita di spingerti troppo in là. Effettua un upload dei dati immediatamente dopo avere mappato qualcosa sul confine.
* Estendi strade, torrenti e altri oggetti lineari leggermente oltre i confini del task: questo consentirà ai mappatori di riprendere da dove hai lasciato, ma ricordati di effettuare un upload dei dati non appena hai finito di editarli.
* Se hai dei dubbi su cosa sia un particolare elemento/oggetto, usa la sezione dei commenti per fare domande oppure controlla sul wiki.
* Se commetti un errore grave - per esempio cancelli elementi/oggetti o una relazione - usa IRC o il riquadro dei commenti per chiedere ad altri mappatori aiuto nel ripristinare la situazione. Cerca di includere il numero del changeset o una descrizione di quello che è successo. Essendo il progetto uno sforzo collaborativo, molti altri mappatori sono disponibili ad aiutare. E' opportuno ricordare che chiunque può a volte commettere errori.
* Non esitare a chiedere un riscontro. I mappatori che validano il tuo lavoro possono avere un atteggiamento sbrigativo o molto diretto, ma se sanno che è possibile dialogare con te, il risultato finale sarà decisamente migliore per tutti quelli coinvolti. Può essere difficile comunicare in un'altra lingua ed è facile apparire bruschi o rudi quando devi tradurre e passare un messaggio in una lingua con cui non hai molta dimestichezza.
* Evita di validate il tuo stesso lavoro. Gli occhi di una seconda persona porteranno sicuramente ad una migliore qualità della mappatura.
* Non preoccuparti se altri mappatori hanno un atteggiamento un po' brusco quando validano il tuo lavoro - come te vogliono assicurarsi che tutti i dati siano stati mappati accuratamente. Il riscontro fornito è in ogni caso riferito  al lavoro rimanente da fare e non va considerato come una critica agli sforzi che hai fatto fino a quel momento.

## Validazione

La validazione è il processo in cui un secondo mappatore riesamina il lavoro svolto dal mappatore che ha preso precedentement in carico un task. E' pensato per assicurarsi che i dati siano di qualità e completi ed è inoltre usato per inviare ringraziamenti, riscontri e per incoraggiare i mappatori.

### Per iniziare

La validazione inizia più o meno allo stesso modo di quando si effettua la mappatura. Un volontario trova un progetto sui cui gli piacerebbe lavorare, legge le istruzioni per essere certo di avere compreso cosa viene richiesto di mappare e come, ma, invece di selezionare il pannello mappatura, seleziona  "Validazione".

![TM select for validation][]

Il validatore può selezionare un task cliccando su un singolo quadrato del task, cliccando "Seleziona un Task a caso", selezionando in base all'utente o disegnando un poligono per selezionare task multipli.

A differenza dei mappatori, i validatori possono selezionare diversi task alla volta per eseguire la validazione su larga scala.

### Selezionare diversi task per la validazione

Una novità dell'ultima versione del Gestore attività è la possibilità di validare molteplici task in una volta sola, selezionandoli per area o per utente.

Questa caratteristica si presente in modi differenti in funzione dell'editor utilizzato.

In JOSM un secondo livello dati verrà creato con il titolo "Confini del Task - Non Editare ne Effettuare l'Upload" e questo, nelle versioni recenti di JOSM, avrà l'upload disabilitato. JOSM **non scaricherà i dati OSM** perchè potrebbero essere una grande quantità. Il validatore dovrà quindi usare i confini del task come guida e scaricare i dati nel livello di editing attivo in modo manuale.

#### Selezione tramite il disegno di un poligono

Questa opzione consente al validatore di disegnare un quadrato attorno ad un gruppo di task e di valutarli tutti assieme in un unica volta.

All'interno dell'editor preferito **il validatore dovrà scaricare manualmente i dati OSM** per l'area selezionata. Questo per prevenire lo scaricamento di tutti i dati OSM in una volta sola.

### Selezione per utente

Viene presentata una lista di mappatori che hanno segnato almeno un task come completato. Passando con il mouse sui nomi nella lista verranno evidenziati i task su cui hanno lavorato. La lista presenta inoltre tre importanti informazioni sul mappatore: il livello di esperienza, il numero di giorni passati da quando ha iniziato ad usare il Gestore attività e il numero di giorni passati dal ricevimento dell'ultimo riscontro di validazione. Questo consente al validatore di focalizzarsi in particolare sui nuovi mappatori, sui mappatori con esperienza o su quelli che non hanno ricevuto riscontri per un lungo periodo di tempo.

Cliccando sul bottone "Inizia la validazione" tutti i task completati dallo specifico mappatore verranno bloccati, permettendo così al validatore di aprirli nell'editor preferito.

![TM multi selection][]

All'interno dell'editor preferito **il validatore dovrà scaricare manualmente i dati OSM** per l'area selezionata. Questo per prevenire lo scaricamento di tutti i dati OSM in una volta sola.

### Concludere la validazione

Non appena il validatore ha concluso il processo di validazione, per un task o più in contemporanea, deve ritornare al Gestore attività e selezionare una delle tre possibili scelte che rispecchiano lo stato di mappatura del task:

- Ferma la validazione - se non puoi completare il processo di validazione e devi fermarti
- Segna (tutti) come Valida - Se la mappatura è completa ed accurata
- Segna (tutti) come non Valida - Se la mappatura non è completa o è inaccurata

Per le ultime due scelte il validatore dovrebbe inviare un commento amichevole e incoraggiante indirizzato ai mappatori coinvolti. Dovrebbe poi ringraziarli per i loro contributi e fornire un riscontro su quanto mappato.  Poni per cortesia attenzione quando segni un task come non valido. Se mancano solo pochi elementi aggiungili tu stesso, spiega cosa mancava nel commento, ma in ogni caso segna il task come valido.  Marcare un task come non valido potrebbe apparire come un commento un po' troppo duro, specialmente per un mappatore principiante che reputava di avere svolto un lavoro completo.

[TM overview]: /images/coordination/tasking_manager_overview.png
[TM Quick Start 1]: /images/coordination/tasking_manager_qs1.png
[TM Quick Start 2]: /images/coordination/tasking_manager_qs2.png
[TM Quick Start 3]: /images/coordination/tasking_manager_qs3.png
[TM Quick Start 4]: /images/coordination/tasking_manager_qs4.png
[TM Quick Start 5]: /images/coordination/tasking_manager_qs5.png
[TM Quick Start 6]: /images/coordination/tasking_manager_qs6.png
[TM Quick Start 7]: /images/coordination/tasking_manager_qs7.png
[TM Quick Start 8]: /images/coordination/tasking_manager_qs8.png
[TM login 1]: /images/coordination/tasking_manager_login1.png
[TM login 2]: /images/coordination/tasking_manager_login2.png
[TM login 3]: /images/coordination/tasking_manager_login3.png
[TM contribute]: /images/coordination/tasking_manager_contribute.png
[TM map tab]: /images/coordination/tasking_manager_map_tab.png
[TM unlock]: /images/coordination/tasking_manager_unlock_task.png
[TM project map]: /images/coordination/tasking_manager_project_map.png
[TM project description]: /images/coordination/tasking_manager_project_description.png
[TM comments]: /images/coordination/tasking_manager_comments.png
[TM task selection]: /images/coordination/tasking_manager_task_selection.png
[TM select for validation]: /images/coordination/tasking_manager_validation_selection.png
[TM multi selection]: /images/coordination/tasking_manager_multi_selection.png


text:
<!-- Auto-generated by x/build/update-readmes.go -->

[![Go Reference](https://pkg.go.dev/badge/golang.org/x/build/cloudfns/sendwikidiff.svg)](https://pkg.go.dev/golang.org/x/build/cloudfns/sendwikidiff)

# golang.org/x/build/cloudfns/sendwikidiff

Package sendwikidiff implements a Google Cloud background function that reacts to a pubsub message containing a GitHub webhook change payload.
<!-- End of auto-generated section -->

## Deploying

```sh
gcloud functions deploy HandleWikiChangePubSub \
  --project=symbolic-datum-552 \
  --runtime go113 \
  --trigger-topic github.webhooks.golang.go.wiki \
  --memory 1024 \
  --set-env-vars="SENDGRID_API_KEY=$(gcloud --project=symbolic-datum-552 secrets versions access latest --secret=sendgrid-sendonly-api-key)"
```


text:
namespace shaka {
namespace js {
namespace mse {

MediaTrack::MediaTrack(std::shared_ptr<media::MediaTrack> track)
    : track_(track) {}

MediaTrack::~MediaTrack() {}

const std::string& MediaTrack::label() const {
  return track_->label;
}

const std::string& MediaTrack::language() const {
  return track_->language;
}

const std::string& MediaTrack::id() const {
  return track_->id;
}

media::MediaTrackKind MediaTrack::kind() const {
  return track_->kind;
}

bool MediaTrack::enabled() const {
  return track_->enabled();
}

void MediaTrack::SetEnabled(bool enabled) {
  track_->SetEnabled(enabled);
}

// \cond Doxygen_Skip
AudioTrack::~AudioTrack() {}
VideoTrack::~VideoTrack() {}
// \endcond Doxygen_Skip

AudioTrackFactory::AudioTrackFactory() {
  AddGenericProperty<AudioTrack>("kind", &MediaTrack::kind);
  AddGenericProperty<AudioTrack>("label", &MediaTrack::label);
  AddGenericProperty<AudioTrack>("language", &MediaTrack::language);
  AddGenericProperty<AudioTrack>("id", &MediaTrack::id);
  AddGenericProperty<AudioTrack>("enabled", &MediaTrack::enabled,
                                 &MediaTrack::SetEnabled);
}

VideoTrackFactory::VideoTrackFactory() {
  AddGenericProperty<VideoTrack>("kind", &MediaTrack::kind);
  AddGenericProperty<VideoTrack>("label", &MediaTrack::label);
  AddGenericProperty<VideoTrack>("language", &MediaTrack::language);
  AddGenericProperty<VideoTrack>("id", &MediaTrack::id);
  // The property is called "selected" on video tracks, but use the same fields
  // as audio for consistency.
  AddGenericProperty<VideoTrack>("selected", &MediaTrack::enabled,
                                 &MediaTrack::SetEnabled);
}

}  // namespace mse
}  // namespace js
}  // namespace shaka


text:
URI: mod_dumpio.html.en
Content-Language: en
Content-type: text/html; charset=ISO-8859-1


text:
from __future__ import unicode_literals

from django.db import migrations, models
import sponsors.models

class Migration(migrations.Migration):

    dependencies = [
        ('sponsors', '0007_rename_sponsor_logo'),
    ]

    operations = [
        migrations.AddField(
            model_name='sponsor',
            name='logo_svg',
            field=models.FileField(blank=True, help_text='Vector format of the logo, in SVG. This takes precedence to the raster format, if available.', upload_to=sponsors.models.logo_upload_to, verbose_name='logo (SVG)'),
        ),
        migrations.AlterField(
            model_name='sponsor',
            name='intro',
            field=models.TextField(verbose_name='introduction'),
        ),
        migrations.AlterField(
            model_name='sponsor',
            name='intro_en_us',
            field=models.TextField(null=True, verbose_name='introduction'),
        ),
        migrations.AlterField(
            model_name='sponsor',
            name='intro_zh_hant',
            field=models.TextField(null=True, verbose_name='introduction'),
        ),
        migrations.AlterField(
            model_name='sponsor',
            name='logo_image',
            field=models.ImageField(help_text='Raster format of the logo, e.g. PNG, JPEG. This is used as fallback when the SVG file is not available.', upload_to=sponsors.models.logo_upload_to, verbose_name='logo (image)'),
        ),
    ]


text:
package drmaa2interface

import (
	"time"
)

// JobSession contains all functions for managing jobs within
// one names job session. Multiple concurrent job sessions can
// be used at one point in time. A job session is a logical
// concept for separating workflows.
type JobSession interface {
	Close() error
	GetContact() (string, error)
	GetSessionName() (string, error)
	GetJobCategories() ([]string, error)
	GetJobs(ji JobInfo) ([]Job, error)
	GetJobArray(id string) (ArrayJob, error)
	RunJob(jt JobTemplate) (Job, error)
	RunBulkJobs(jt JobTemplate, begin int, end int, step int, maxParallel int) (ArrayJob, error)
	WaitAnyStarted(jobs []Job, timeout time.Duration) (Job, error)
	WaitAnyTerminated(jobs []Job, timeout time.Duration) (Job, error)
}


text:
[Unit testing your Redux actions and reducers](unit-testing.md) is nice, but you
can do even more to make sure nothing breaks your application. Since React is
the _view_ layer of your app, let's see how to test Components too!

<!-- TOC depthFrom:2 depthTo:6 withLinks:1 updateOnSave:1 orderedList:0 -->

- [Shallow rendering](#shallow-rendering)
- [Enzyme](#enzyme)

<!-- /TOC -->

## Shallow rendering

React provides us with a nice add-on called the Shallow Renderer. This renderer
will render a React component **one level deep**. Lets take a look at what that
means with a simple `<Button>` component...

This component renders a `<button>` element containing a checkmark icon and some
text:

```javascript
// Button.react.js

import CheckmarkIcon from './CheckmarkIcon.react';

function Button(props) {
  return (
    <button className="btn" onClick={props.onClick}>
      <CheckmarkIcon />
      { props.children }
    </button>
  );
}

export default Button;
```

_Note: This is a [state**less** ("dumb") component](../js/README.md#architecture-components-and-containers)_

It might be used in another component like this:

```javascript
// HomePage.react.js

import Button from './Button.react';

class HomePage extends React.Component {
  render() {
    return(
      <Button onClick={this.doSomething}>Click me!</Button>
    );
  }
}
```

_Note: This is a [state**ful** ("smart") component](../js/README.md#architecture-components-and-containers)!_

When rendered normally with the standard `ReactDOM.render` function, this will
be the HTML output
(*Comments added in parallel to compare structures in HTML from JSX source*):

```html
<button>                           <!-- <Button>             -->
  <i class="fa fa-checkmark"></i>  <!--   <CheckmarkIcon />  -->
  Click Me!                        <!--   { props.children } -->
</button>                          <!-- </Button>            -->
```

Conversely, when rendered with the shallow renderer, we'll get a String
containing this "HTML":

```html
<button>              <!-- <Button>             -->
  <CheckmarkIcon />   <!--   NOT RENDERED!      -->
  Click Me!           <!--   { props.children } -->
</button>             <!-- </Button>            -->
```

If we test our `Button` with the normal renderer and there's a problem
with the `CheckmarkIcon` then the test for the `Button` will fail as well...
but finding the culprit will be hard. Using the _shallow_ renderer, we isolate
the problem's cause since we don't render any other components other than the
one we're testing!

The problem with the shallow renderer is that all assertions have to be done
manually, and you cannot do anything that needs the DOM.

Thankfully, [AirBnB](https://twitter.com/AirbnbEng) has open sourced their
wrapper around the React shallow renderer and jsdom, called `enzyme`. `enzyme`
is a testing utility that gives us a nice assertion/traversal/manipulation API.

## Enzyme

Lets test our `<Button>` component! We're going to assess three things: First,
that it renders a HTML `<button>` tag, second that it renders its children we
pass it and third that handles clicks!

This is our Mocha setup:

```javascript
describe('<Button />', () => {
  it('renders a <button>', () => {});

  it('renders its children', () => {});

  it('handles clicks', () => {});
});
```

Lets start with testing that it renders a `<button>`. To do that we first
`shallow` render it, and then `expect` that a `<button>` node exists.

```javascript
it('renders a <button>', () => {
  const renderedComponent = shallow(
    <Button></Button>
  );
  expect(
    renderedComponent.find("button").node
  ).toExist();
});
```

Nice! If somebody breaks our button component by having it render an `<a>` tag
or something else we'll immediately know! Let's do something a bit more advanced
now, and check that our `<Button>` renders its children.

We render our button component with some text, and then verify that our text
exists:

```javascript
it('renders its children', () => {
  const text = "Click me!";
  const renderedComponent = shallow(
    <Button>{ text }</Button>
  );
  expect(
    renderedComponent.contains(text)
  ).toEqual(true);
});
```

Great! Onwards to our last and most advanced test: checking that our `<Button>` handles clicks correctly. We'll use a Spy for that. A Spy is a
function that knows if, and how often, it has been called. We create the Spy
(thoughtfully provided by `expect`), pass _it_ as the `onClick` handler to our
component, simulate a click on the rendered `<button>` element and, lastly,
see that our Spy was called:

```javascript
it('handles clicks', () => {
  const onClickSpy = expect.createSpy();
  const renderedComponent = shallow(<Button onClick={onClickSpy} />);
  renderedComponent.find('button').simulate('click');
  expect(onClickSpy).toHaveBeenCalled();
});
```

And that's how you unit test your components and make sure they work correctly!


text:
#include "GLSLCompileThread.h"

#include <QOpenGLFunctions>
#include <QFile>

GLSLCompileThread::GLSLCompileThread(QOpenGLContext * shareContext, QObject * parent)
	: QThread(parent)
	, m_context(nullptr)
	, m_surface(nullptr)
	, m_quit(false)
{
	if (shareContext == nullptr)
	{
		throw std::runtime_error("GLSLCompileThread::GLSLCompileThread() - NULL context passed!");
	}
	//allocate shared context
	m_context = new QOpenGLContext();
	m_context->setFormat(shareContext->format());
	m_context->setShareContext(shareContext);
	m_context->moveToThread(this);
	m_context->create();
	//do not create the context now, but later in run()
	//create invisible surface to make context current
	m_surface = new QOffscreenSurface();
	m_surface->setFormat(shareContext->format());
	m_surface->create();
}

GLSLCompileThread::~GLSLCompileThread()
{
	m_quit = true;
	m_condition.wakeAll();
	wait();
	delete m_context;
	delete m_surface;
}

void GLSLCompileThread::compileAndLink(QString vertexCode, QString fragmentCode, bool asynchronous)
{
	QMutexLocker locker(&m_mutex);
	//check if we want asynchronous compilation
	if (asynchronous)
	{
		m_vertexCode = vertexCode;
		m_fragmentCode = fragmentCode;
		if (!isRunning())
		{
			start();
		}
		else
		{
			m_condition.wakeOne();
		}
	}
	else
	{
		compileInternal(vertexCode, fragmentCode);
	}
}

void GLSLCompileThread::compileInternal(QString vertexCode, QString fragmentCode)
{
	//try to compile the fragment shader
	QString errors;
	QByteArray vertexCode8Bit = vertexCode.toLatin1();
	QByteArray fragmentCode8Bit = fragmentCode.toLatin1();
	/*QFile dumpV("code_vertex.bin");
	dumpV.open(QIODevice::WriteOnly | QIODevice::Truncate);
	dumpV.write(vertexCode8Bit);
	dumpV.close();
	QFile dumpF("code_fragment.bin");
	dumpF.open(QIODevice::WriteOnly | QIODevice::Truncate);
	dumpF.write(fragmentCode8Bit);
	dumpF.close();
	fragmentCode8Bit.replace(0x0A, "\n");*/
	QOpenGLShader * fragmentShader = new QOpenGLShader(QOpenGLShader::Fragment);
	if (!fragmentShader->compileSourceCode(fragmentCode8Bit))
	{
		errors.append(fragmentShader->log());
		delete fragmentShader;
		emit result(nullptr, nullptr, nullptr, false, errors);
	}
	else
	{
		//fragment shader is ok. try compiling vertex shader
		QOpenGLShader * vertexShader = new QOpenGLShader(QOpenGLShader::Vertex);
		if (!vertexShader->compileSourceCode(vertexCode8Bit))
		{
			errors.append(vertexShader->log());
			delete fragmentShader;
			delete vertexShader;
			emit result(nullptr, nullptr, nullptr, false, errors);
		}
		else
		{
			//compilation worked. try linking
			QOpenGLShaderProgram * program = new QOpenGLShaderProgram();
			program->addShader(vertexShader);
			program->addShader(fragmentShader);
			if (!program->link())
			{
				errors.append(program->log());
				delete fragmentShader;
				delete vertexShader;
				delete program;
				emit result(nullptr, nullptr, nullptr, false, errors);
			}
			else
			{
				//wow. when we get there all's fine
				emit result(vertexShader, fragmentShader, program, true, QString());
			}
		}
	}
}

void GLSLCompileThread::run()
{
	//create context NOW
	/*if (!m_context->isValid())
	{
		m_context->create();
	}*/
	//loop while thread is running
	while (!m_quit)
	{
		m_mutex.lock();
		QString vertexCode = m_vertexCode;// .toLocal8Bit();
		QString fragmentCode = m_fragmentCode;// .toLocal8Bit();
		m_mutex.unlock();
		//check if we have valid data
		if (m_context && m_context->isValid() && !vertexCode.isEmpty() && !fragmentCode.isEmpty())
		{
			//make context current in this thread
			m_context->makeCurrent(m_surface);
			//now compile shader
			compileInternal(vertexCode, fragmentCode);
			//release context
			m_context->doneCurrent();
		}
		//wait until further notice
		m_mutex.lock();
		m_condition.wait(&m_mutex);
		m_mutex.unlock();
	}
}


text:
require 'spec_helper'
require 'turbot/command/version'

describe Turbot::Command::Version do
  describe 'version' do
    it 'shows the version' do
      %w(version --version).each do |command|
        stderr, stdout = execute(command)

        expect(stderr).to eq('')
        expect(stdout).to eq <<-STDOUT
#{Turbot::DEBUG_VERSION}
STDOUT
      end
    end
  end
end


text:
echo "Type your e-mail, followed by [ENTER]:"
read email

echo "ftp://anonymous:$email@ftp.omim.borg/OMIM/morbidmap"
curl -s "ftp://anonymous:$email@ftp.omim.borg/OMIM/morbidmap" > morbidmap

#wget ftp://ftp.ebi.ac.uk/pub/databases/genenames/locus_groups/protein-coding_gene.txt.gz
#tar -zxvf protein-coding_gene.txt.gz