text:
package org.jgroups.tests;

import org.jgroups.*;
import org.jgroups.protocols.*;
import org.jgroups.protocols.pbcast.*;
import org.jgroups.stack.Protocol;
import org.jgroups.util.Util;
import org.testng.annotations.Test;

import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

/**
 * Tests the FLUSH protocol. Adds a FLUSH layer on top of the stack unless already present. Should
 * work with any stack.
 *
 * @author Bela Ban
 */
@Test(groups = {Global.FLUSH, Global.EAP_EXCLUDED}, sequential = true)
public class FlushTest {

    public void testSingleChannel() throws Exception {
        Semaphore s = new Semaphore(1);
        FlushTestReceiver receivers[] ={ new FlushTestReceiver("c1", s, 0, FlushTestReceiver.CONNECT_ONLY) };
        receivers[0].start();
        s.release(1);

        // Make sure everyone is in sync
        JChannel[] tmp = new JChannel[receivers.length];
        for (int i = 0; i < receivers.length; i++)
            tmp[i] = receivers[i].getChannel();
        Util.waitUntilAllChannelsHaveSameView(10000, 1000, tmp);

        // Reacquire the semaphore tickets; when we have them all we know the threads are done
        s.tryAcquire(1, 10, TimeUnit.SECONDS);
        receivers[0].cleanup();
        Util.sleep(1000);

        checkEventStateTransferSequence(receivers[0]);
    }

    /** Tests issue #1 in http://jira.jboss.com/jira/browse/JGRP-335 */
    public void testJoinFollowedByUnicast() throws Exception {
        JChannel a=null, b=null;
        try {
            a = createChannel("A");
            a.setReceiver(new SimpleReplier(a,true));
            a.connect("testJoinFollowedByUnicast");

            Address target = a.getAddress();
            Message unicast_msg = new Message(target);

            b = createChannel("B");
            b.setReceiver(new SimpleReplier(b,false));
            b.connect("testJoinFollowedByUnicast");

            // now send unicast, this might block as described in the case
            b.send(unicast_msg);
            // if we don't get here this means we'd time out
        } finally {
            Util.close(b, a);
        }
    }

    /**
     * Tests issue #2 in http://jira.jboss.com/jira/browse/JGRP-335
     */
    public void testStateTransferFollowedByUnicast() throws Exception {
        JChannel a=null, b=null;
        try {
            a = createChannel("A");
            a.setReceiver(new SimpleReplier(a,true));
            a.connect("testStateTransferFollowedByUnicast");

            Address target = a.getAddress();
            Message unicast_msg = new Message(target);

            b = createChannel("B");
            b.setReceiver(new SimpleReplier(b,false));
            b.connect("testStateTransferFollowedByUnicast");

            System.out.println("\n** Getting the state **");
            b.getState(null,10000);
            // now send unicast, this might block as described in the case
            b.send(unicast_msg);
        } finally {
            Util.close(b, a);
        }
    }

    public void testSequentialFlushInvocation() throws Exception {
        JChannel a=null, b=null, c=null;
        try {
            a = createChannel("A");
            a.connect("testSequentialFlushInvocation");

            b = createChannel("B");
            b.connect("testSequentialFlushInvocation");

            c = createChannel("C");
            c.connect("testSequentialFlushInvocation");

            Util.waitUntilAllChannelsHaveSameView(10000, 1000, a, b, c);

            for (int i = 0; i < 100; i++) {
                System.out.print("flush #" + i + ": ");
                a.startFlush(false);
                a.stopFlush();
                System.out.println("OK");
            }
        } finally {
            Util.close(a, b, c);
        }
    }

    public void testFlushWithCrashedFlushCoordinator() throws Exception {
        JChannel a=null, b=null, c=null;
        try {
            a = createChannel("A");
            b = createChannel("B");
            c = createChannel("C");
            changeProps(a,b,c);
            b.connect("testFlushWithCrashedFlushCoordinator");
            a.connect("testFlushWithCrashedFlushCoordinator");

            c.connect("testFlushWithCrashedFlushCoordinator");

            Util.waitUntilAllChannelsHaveSameView(10000, 500, a,b,c);

            System.out.println("shutting down flush coordinator B");
            b.down(new Event(Event.SUSPEND_BUT_FAIL)); // send out START_FLUSH and then return

            // now shut down B. This means, after failure detection kicks in and the new coordinator takes over
            // (either A or C), that the current flush started by B will be cancelled and a new flush (by A or C)
            // will be started
            Util.shutdown(b);
            Stream.of(a,c).forEach(ch -> ch.getProtocolStack().findProtocol(FLUSH.class).setLevel("debug"));

            for(int i=0; i < 20; i++) {
                if(Stream.of(a,c).allMatch(ch -> ch.view().size() == 2))
                    break;
                Util.sleep(500);
            }

            // cluster should not hang and two remaining members should have a correct view
            assert a.getView().size() == 2 : String.format("A's view: %s", a.getView());
            assert c.getView().size() == 2 : String.format("C's view: %s", c.getView());
        }
        finally {
            Util.close(c, b, a);
        }
    }

    public void testFlushWithCrashedParticipant() throws Exception {
        JChannel a=null, b=null, c=null;

        try {
            a = createChannel("A"); changeProps(a);
            a.connect("testFlushWithCrashedParticipant");

            b = createChannel("B"); changeProps(b);
            b.connect("testFlushWithCrashedParticipant");

            c = createChannel("C"); changeProps(c);
            c.connect("testFlushWithCrashedParticipant");

            System.out.println("shutting down C3");
            Util.shutdown(c); // kill a flush participant

            System.out.println("C2: starting flush");
            boolean rc=Util.startFlush(b);
            System.out.println("flush " + (rc? " was successful" : "failed"));
            assert rc;

            System.out.println("stopping flush");
            b.stopFlush();

            System.out.println("waiting for view to contain C1 and C2");
            Util.waitUntilAllChannelsHaveSameView(10000, 500, a, b);

            // cluster should not hang and two remaining members should have a correct view
            System.out.println("C1: view=" + a.getView() + "\nC2: view=" + b.getView());
            assert a.getView().size() == 2;
            assert b.getView().size() == 2;
        } finally {
            Util.close(c, b, a);
        }
    }

    public void testFlushWithCrashedParticipants() throws Exception {
        JChannel a=null, b=null, c=null;

        try {
            a = createChannel("A"); changeProps(a);
            a.connect("testFlushWithCrashedFlushCoordinator");

            b = createChannel("B"); changeProps(b);
            b.connect("testFlushWithCrashedFlushCoordinator");

            c = createChannel("C"); changeProps(c);
            c.connect("testFlushWithCrashedFlushCoordinator");

            // and then kill members other than flush coordinator
            Util.shutdown(c);
            Util.shutdown(a);

            // start flush
            Util.startFlush(b);

            b.stopFlush();
            for(int i=0; i < 20; i++) {
                if(b.getView().size() == 1)
                    break;
                Util.sleep(500);
            }

            // cluster should not hang and one remaining member should have a correct view
            assert b.getView().size() == 1 : String.format("B's view is %s", b.getView());
        } finally {
            Util.close(c, b, a);
        }
    }

    /**
     * Tests http://jira.jboss.com/jira/browse/JGRP-661
     */
    public void testPartialFlush() throws Exception {
        JChannel a=null, b=null;
        try {
            a = createChannel("A");
            a.setReceiver(new SimpleReplier(a,true));
            a.connect("testPartialFlush");

            b = createChannel("B");
            b.setReceiver(new SimpleReplier(b,false));
            b.connect("testPartialFlush");

            List<Address> members = new ArrayList<>();
            members.add(b.getAddress());
            assert Util.startFlush(b, members);
            b.stopFlush(members);
        } finally {
            Util.close(b, a);
        }
    }

    /** Tests the emition of block/unblock/get|set state events */
    public void testBlockingNoStateTransfer() throws Exception {
        String[] names = { "A", "B", "C", "D" };
        _testChannels(names, FlushTestReceiver.CONNECT_ONLY);
    }

    /** Tests the emition of block/unblock/get|set state events */
    public void testBlockingWithStateTransfer() throws Exception {
        String[] names = { "A", "B", "C", "D" };
        _testChannels(names, FlushTestReceiver.CONNECT_AND_SEPARATE_GET_STATE);
    }

    /** Tests the emition of block/unblock/get|set state events */
    public void testBlockingWithConnectAndStateTransfer() throws Exception {
        String[] names = { "A", "B", "C", "D" };
        _testChannels(names, FlushTestReceiver.CONNECT_AND_GET_STATE);
    }

    private void _testChannels(String names[], int connectType) throws Exception {
        int count = names.length;

        List<FlushTestReceiver> channels = new ArrayList<>(count);
        try {
            // Create a semaphore and take all its permits
            Semaphore semaphore = new Semaphore(count);
            semaphore.acquire(count);

            // Create channels and their threads that will block on the
            // semaphore
            boolean first = true;
            for (String channelName : names) {
                FlushTestReceiver channel = null;
                channel = new FlushTestReceiver(channelName, semaphore, 0, connectType);
                channels.add(channel);

                // Release one ticket at a time to allow the thread to start working
                channel.start();
                semaphore.release(1);
                if (first)
                    Util.sleep(3000); // minimize changes of a merge happening
                first = false;
            }

            JChannel[] tmp = new JChannel[channels.size()];
            int cnt = 0;
            for (FlushTestReceiver receiver : channels)
                tmp[cnt++] = receiver.getChannel();
            Util.waitUntilAllChannelsHaveSameView(30000, 1000, tmp);

            // Reacquire the semaphore tickets; when we have them all
            // we know the threads are done
            semaphore.tryAcquire(count, 40, TimeUnit.SECONDS);

            Util.sleep(1000); //let all events propagate...
            for (FlushTestReceiver app : channels)
                app.getChannel().setReceiver(null);
            channels.forEach(FlushTestReceiver::cleanup);

            // verify block/unblock/view/get|set state sequences for all members
            for (FlushTestReceiver receiver : channels) {
                checkEventStateTransferSequence(receiver);
                System.out.println("event sequence is OK");
            }
        }
        finally {
            channels.forEach(FlushTestReceiver::cleanup);
        }
    }

    protected static void checkEventStateTransferSequence(EventSequence receiver) {
        String events = receiver.getEventSequence();
        assert events != null;
        final String validSequence = "([b][vgs]*[u])+";
        // translate the eventTrace to an eventString
        try {
            assert validateEventString(translateEventTrace(events), validSequence) : "Invalid event sequence " + events;
        } catch (Exception e) {
            assert false : "Invalid event sequence " + events;
        }
    }

    /**
     * Method for validating event strings against event string specifications, where a
     * specification is a regular expression involving event symbols. e.g. [b]([sgv])[u]
     */
    protected static boolean validateEventString(String eventString, String spec) {
        Pattern pattern = null;
        Matcher matcher = null;

        // set up the regular expression specification
        pattern = Pattern.compile(spec);
        // set up the actual event string
        matcher = pattern.matcher(eventString);

        // check if the actual string satisfies the specification
        if (matcher.find()) {
            // a match has been found, but we need to check that the whole event string
            // matches, and not just a substring
            if (!(matcher.start() == 0 && matcher.end() == eventString.length())) {
                // match on full eventString not found
                System.err.println("event string invalid (proper substring matched): event string = "
                                     + eventString
                                     + ", specification = "
                                     + spec
                                     + "matcher.start() "
                                     + matcher.start()
                                     + " matcher.end() " + matcher.end());
                return false;
            }
        } else {
            return false;
        }
        return true;
    }

    /**
     * Method for translating event traces into event strings, where each event in the trace is
     * represented by a letter.
     */
    protected static String translateEventTrace(String s) throws Exception {
        // if it ends with block, strip it out because it will be regarded as error sequence
        while (s.endsWith("b")) {
            s = s.substring(0, s.length() - 1);
        }
        return s;
    }

    protected JChannel createChannel(String name) throws Exception {
          Protocol[] protocols={
            new SHARED_LOOPBACK(),
            new SHARED_LOOPBACK_PING(),
            new FD_ALL().setValue("timeout", 3000).setValue("interval", 1000),
            new NAKACK2(),
            new UNICAST3(),
            new STABLE(),
            new GMS(),
            new FRAG2().fragSize(8000),
            new STATE_TRANSFER(),
            new FLUSH()
          };

          return new JChannel(protocols).name(name);
      }

    private static void changeProps(JChannel ... channels) {
        for(JChannel ch: channels) {
            FD fd=ch.getProtocolStack().findProtocol(FD.class);
            if(fd != null) {
                fd.setTimeout(1000);
                fd.setMaxTries(2);
            }
            FD_ALL fd_all=ch.getProtocolStack().findProtocol(FD_ALL.class);
            if(fd_all != null) {
                fd_all.setTimeout(2000);
                fd_all.setInterval(800);
                fd_all.setTimeoutCheckInterval(3000);
            }
        }
    }

    private class FlushTestReceiver extends ReceiverAdapter implements Runnable, EventSequence {
        private final int             connectMethod;
        public static final int       CONNECT_ONLY = 1;
        public static final int       CONNECT_AND_SEPARATE_GET_STATE = 2;
        public static final int       CONNECT_AND_GET_STATE = 3;
        protected int                 msgCount = 0;
        protected final StringBuilder events=new StringBuilder();
        protected final Semaphore     semaphore;
        protected final JChannel      channel;
        protected Thread              thread;
        protected Exception           exception;

        protected FlushTestReceiver(String name, Semaphore semaphore, int msgCount,
                        int connectMethod) throws Exception {
            this.semaphore=semaphore;
            this.connectMethod = connectMethod;
            this.msgCount = msgCount;
            this.channel=createChannel(name);
            this.channel.setReceiver(this);
            if (connectMethod == CONNECT_ONLY || connectMethod == CONNECT_AND_SEPARATE_GET_STATE)
                channel.connect("FlushTestReceiver");

            if (connectMethod == CONNECT_AND_GET_STATE) {
                channel.connect("FlushTestReceiver", null, 25000);
            }
        }

        public void start() {
            thread=new Thread(this);
            thread.start();
        }

        public void cleanup() {
            Util.close(channel);
            thread.interrupt();
        }

        public String    getEventSequence()   {return events.toString();}
        public Exception getException()       {return exception;}
        public JChannel  getChannel()         {return channel;}
        public String    getName()            {return channel != null? channel.getName() : "n/a";}
        public void      block()              {events.append('b');}
        public void      unblock()            {events.append('u');}
        public void      viewAccepted(View v) {events.append('v');}

        public void getState(OutputStream ostream) throws Exception {
            events.append('g');
            byte[] payload ={ 'b', 'e', 'l', 'a' };
            ostream.write(payload);
        }

        public void setState(InputStream istream) throws Exception {
            events.append('s');
            byte[] payload = new byte[4];
            istream.read(payload);
        }

        public void run() {
            try {
                if (connectMethod == CONNECT_AND_SEPARATE_GET_STATE) {
                    channel.getState(null, 25000);
                }
                if (msgCount > 0) {
                    for (int i = 0; i < msgCount; i++) {
                        channel.send(new Message());
                        Util.sleep(100);
                    }
                }
            }
            catch(Exception ex) {
                exception=ex;
            }
        }
    }

    private static class SimpleReplier extends ReceiverAdapter {
        protected final JChannel channel;
        protected boolean       handle_requests=false;

        public SimpleReplier(JChannel channel, boolean handle_requests) {
            this.channel = channel;
            this.handle_requests = handle_requests;
        }

        public void receive(Message msg) {
            Message reply = new Message(msg.getSrc());
            try {
                System.out.println("-- MySimpleReplier[" + channel.getAddress() + "]: received message from " + msg.getSrc());
                if (handle_requests) {
                    System.out.println(", sending reply");
                    channel.send(reply);
                } else
                    System.out.println("\n");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public void viewAccepted(View new_view) {
            System.out.println("-- MySimpleReplier[" + channel.getAddress() + "]: viewAccepted(" + new_view + ")");
        }

        public void block() {
            System.out.println("-- MySimpleReplier[" + channel.getAddress() + "]: block()");
        }

        public void unblock() {
            System.out.println("-- MySimpleReplier[" + channel.getAddress() + "]: unblock()");
        }
    }

    interface EventSequence {
        /** Return an event string. Events are translated as follows: get state='g', set state='s',
         *  block='b', unlock='u', view='v' */
        String getEventSequence();
        String getName();
    }

}


text:
package leap.core.security;

public interface TrustedCredentials extends Credentials {
}

redpajama_set_name: RedPajamaGithub


text:
package io.atomix.storage.journal;

import io.atomix.storage.StorageException;
import io.atomix.storage.journal.index.JournalIndex;
import io.atomix.utils.serializer.Namespace;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * Mappable log segment reader.
 */
class MappableJournalSegmentReader<E> implements JournalReader<E> {
  private final JournalSegment<E> segment;
  private final FileChannel channel;
  private final int maxEntrySize;
  private final JournalIndex index;
  private final Namespace namespace;
  private JournalReader<E> reader;

  MappableJournalSegmentReader(
      FileChannel channel,
      JournalSegment<E> segment,
      int maxEntrySize,
      JournalIndex index,
      Namespace namespace) {
    this.channel = channel;
    this.segment = segment;
    this.maxEntrySize = maxEntrySize;
    this.index = index;
    this.namespace = namespace;
    this.reader = new FileChannelJournalSegmentReader<>(channel, segment, maxEntrySize, index, namespace);
  }

  /**
   * Converts the reader to a mapped reader using the given buffer.
   *
   * @param buffer the mapped buffer
   */
  void map(ByteBuffer buffer) {
    if (!(reader instanceof MappedJournalSegmentReader)) {
      JournalReader<E> reader = this.reader;
      this.reader = new MappedJournalSegmentReader<>(buffer, segment, maxEntrySize, index, namespace);
      this.reader.reset(reader.getNextIndex());
      reader.close();
    }
  }

  /**
   * Converts the reader to an unmapped reader.
   */
  void unmap() {
    if (reader instanceof MappedJournalSegmentReader) {
      JournalReader<E> reader = this.reader;
      this.reader = new FileChannelJournalSegmentReader<>(channel, segment, maxEntrySize, index, namespace);
      this.reader.reset(reader.getNextIndex());
      reader.close();
    }
  }

  @Override
  public long getFirstIndex() {
    return reader.getFirstIndex();
  }

  @Override
  public long getCurrentIndex() {
    return reader.getCurrentIndex();
  }

  @Override
  public Indexed<E> getCurrentEntry() {
    return reader.getCurrentEntry();
  }

  @Override
  public long getNextIndex() {
    return reader.getNextIndex();
  }

  @Override
  public boolean hasNext() {
    return reader.hasNext();
  }

  @Override
  public Indexed<E> next() {
    return reader.next();
  }

  @Override
  public void reset() {
    reader.reset();
  }

  @Override
  public void reset(long index) {
    reader.reset(index);
  }

  @Override
  public void close() {
    reader.close();
    try {
      channel.close();
    } catch (IOException e) {
      throw new StorageException(e);
    } finally {
      segment.closeReader(this);
    }
  }
}


text:
if node.platform_family == "rhel"
  user = "apache"
  group = "apache"
  conf_dir = "/etc/php.d"
  pool_conf_dir = "/etc/php-fpm.d"
  conf_file = "/etc/php-fpm.conf"
  error_log = "/var/log/php-fpm/error.log"
  pid = "/var/run/php-fpm/php-fpm.pid"
else
  user = "www-data"
  group = "www-data"
  conf_dir = "/etc/php5/fpm/conf.d"
  pool_conf_dir = "/etc/php5/fpm/pool.d"
  if node.platform == "ubuntu" and node.platform_version.to_f <= 10.04
    conf_file = "/etc/php5/fpm/php5-fpm.conf"
  else
    conf_file = "/etc/php5/fpm/php-fpm.conf"
  end
  error_log = "/var/log/php5-fpm.log"
  pid ="/var/run/php5-fpm.pid"
end

default['php-fpm']['user'] = user
default['php-fpm']['group'] = group
default['php-fpm']['conf_dir'] = conf_dir
default['php-fpm']['pool_conf_dir'] = pool_conf_dir
default['php-fpm']['conf_file'] = conf_file
default['php-fpm']['pid'] = pid
default['php-fpm']['error_log'] =  error_log
default['php-fpm']['log_level'] = "notice"
default['php-fpm']['emergency_restart_threshold'] = 0
default['php-fpm']['emergency_restart_interval'] = 0
default['php-fpm']['process_control_timeout'] = 0
default['php-fpm']['pools'] = [
  {
    :name => "www"
  }
]

default['php-fpm']['yum_url'] = "http://rpms.famillecollet.com/enterprise/$releasever/remi/$basearch/"
default['php-fpm']['yum_mirrorlist'] = "http://rpms.famillecollet.com/enterprise/$releasever/remi/mirror"


text:
const DEG_RAD_CONVERSION_FACTOR = Math.PI/180;

//rotate the specified 2d vector by the given angle
exports.rotate2d = function(vector, angle){
    //convert degrees to radians
    angle = angle * DEG_RAD_CONVERSION_FACTOR;
    //trig is slow, only calculate once
    var cos = Math.cos(angle);
    var sin = Math.sin(angle);
    return {
        x : vector.x * cos - vector.y * sin,
        y : vector.y * cos + vector.x * sin,
    };
};


text:
/*
* Minimum Path Sum.
* https://leetcode.com/problems/decode-ways/
*
* A message containing letters from A-Z is being encoded to numbers using the fo
* -llowing mapping:
*
* 'A' -> 1
* 'B' -> 2
* ...
* 'Z' -> 26
* Given an encoded message containing digits, determine the total number of ways
* to decode it.
*
* For example,
* Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
*
* The number of ways decoding "12" is 2.
*
*/

#ifndef SOLUTIONS_DECODE_WAYS_H_
#define SOLUTIONS_DECODE_WAYS_H_

#include <string>

class DecodeWays {
public:
  const int kMinEncodingNumber = 1;
  const int kMaxEncodingNumber = 26;
  int numDecodings(const std::string& s);
};

#endif  // SOLUTIONS_DECODE_WAYS_H_


text:
@interface UIImage (Transformations)

- (id)copyWithZone:(NSZone*)zone;
- (UIImage*)flippedImage;
- (UIImage*)uprightImage;
- (UIImage*)croppedImage:(CGRect)bounds;
- (UIImage*)resizedImage:(CGSize)newSize interpolationQuality:(CGInterpolationQuality)quality;
- (UIImage*)resizedImageWithContentMode:(UIViewContentMode)contentMode
                                  bounds:(CGSize)bounds
                    interpolationQuality:(CGInterpolationQuality)quality;
- (UIImage*)rotatedImage:(CGFloat)radians fillColor:(UIColor*)fillColor;

@end


text:
define({
  "layersPage": {
    "allLayers": "Tutti i layer",
    "title": "Selezionare un modello per creare le feature",
    "generalSettings": "Impostazioni generali",
    "layerSettings": "Impostazioni layer",
    "smartActionsTabTitle": "Azioni smart",
    "attributeActionsTabTitle": "Azioni attributo",
    "geocoderSettingsText": "Impostazioni geocoder",
    "editDescription": "Fornire testo da visualizzare per il riquadro di modifica",
    "editDescriptionTip": "Questo testo viene visualizzato sopra il selettore dei modelli, lasciare vuoto in assenza di testo.",
    "promptOnSave": "Richiedere di salvare modifiche non salvate quando il modulo viene chiuso o passato al record successivo.",
    "promptOnSaveTip": "Visualizzare un prompt quando l'utente fa clic su Chiudi o passare al successivo record modificabile quando la feature corrente contiene modifiche non salvate.",
    "promptOnDelete": "Richiedere la conferma durante la cancellazione di un record.",
    "promptOnDeleteTip": "Visualizza un prompt quando l'utente fa clic su Cancella per confermare l'azione.",
    "removeOnSave": "Rimuove la feature dalla selezione al salvataggio.",
    "removeOnSaveTip": "Opzione per rimuovere la feature dalla selezione impostata quando il record viene salvato. Se è il solo record selezionato, il pannello viene riportato alla pagina del modello.",
    "useFilterEditor": "Utilizza filtro modello di feature",
    "useFilterEditorTip": "Opzione per utilizzare il selettore Filtra Template, che consente di visualizzare il template di un layer o di cercare template in base al nome.",
    "displayShapeSelector": "Mostra opzioni del disegno",
    "createNewFeaturesFromExisting": "Consenti all'utente di creare nuove feature da feature esistenti",
    "createNewFeaturesFromExistingTip": "Opzione per consentire all'utente di copiare la feature esistente per creare nuove feature",
    "copiedFeaturesOverrideDefaults": "I valori delle feature copiate sostituiscono i valori predefiniti",
    "copiedFeaturesOverrideDefaultsTip": "I valori delle feature copiate sostituiscono i valori predefiniti del modello solo per i campi corrispondenti",
    "displayShapeSelectorTip": "Opzione per mostrare un elenco di opzioni valide per il disegno per il modello selezionato.",
    "displayPresetTop": "Mostra in alto l'elenco dei valori preimpostati",
    "displayPresetTopTip": "Opzione per mostrare l'elenco dei valori preimpostati nella selezione di modelli.",
    "listenToGroupFilter": "Applica valori ai filtri dal widget Filtro gruppo ai campi preimpostati",
    "listenToGroupFilterTip": "Quando un filtro viene applicato nel widget Filtro gruppo, applicare il valore a un campo corrispondente nell'elenco dei valori preimpostati.",
    "keepTemplateActive": "Mantieni attivo il modello selezionato",
    "keepTemplateActiveTip": "Quando viene visualizzato il selettore dei modelli, se un modello è stato selezionato in precedenza, selezionarlo nuovamente.",
    "geometryEditDefault": "Abilita la modifica della geometria per impostazione predefinita",
    "autoSaveEdits": "Salva automaticamente nuove feature",
    "enableAttributeUpdates": "Mostra il pulsante di aggiornamento delle azioni attributo quando la modifica della geometria è attiva",
    "enableAutomaticAttributeUpdates": "Richiamare automaticamente Azioni attributo dopo l'aggiornamento della geometria",
    "enableLockingMapNavigation": "Abilita blocco di navigazione della mappa",
    "enableMovingSelectedFeatureToGPS": "Abilita lo spostamento della feature puntuale selezionata sulla posizione GPS",
    "enableMovingSelectedFeatureToXY": "Abilita lo spostamento della feature puntuale selezionata nella posizione XY",
    "featureTemplateLegendLabel": "Impostazioni di Modello feature e Filtra valore",
    "saveSettingsLegendLabel": "Salva Impostazioni",
    "geometrySettingsLegendLabel": "Impostazioni geometria",
    "buttonPositionsLabel": "Posizione dei pulsanti Salva, Elimina, Indietro e Cancella",
    "belowEditLabel": "Sotto il modulo di modifica",
    "aboveEditLabel": "Sopra il modulo di modifica",
    "switchToMultilineInput": "Passare a input multilineari quando viene superata la lunghezza del campo",
    "layerSettingsTable": {
      "allowDelete": "Consenti cancellazione",
      "allowDeleteTip": "Consenti cancellazione: opzione per consentire all'utente di cancellare una feature; disabilitata se il layer non supporta la cancellazione",
      "edit": "Modificabile",
      "editTip": "Modificabile: opzione per includere il layer nel widget",
      "label": "Layer",
      "labelTip": "Layer: nome del layer come definito nella mappa",
      "update": "Disabilita modifica geometria",
      "updateTip": "Disabilita modifica geometria: opzione per disabilitare la possibilità di spostare la geometria dopo che è stata posizionata o spostare la geometria su una feature esistente",
      "allowUpdateOnly": "Solo aggiornamento",
      "allowUpdateOnlyTip": "Solo aggiornamento: opzione per consentire solo la modifica delle feature esistenti, selezionata per impostazione predefinita e disabilitata se il layer non supporta la creazione di nuove feature",
      "fieldsTip": "Modificare i campi da modificare e definire attributi Smart",
      "actionsTip": "Azioni: opzione per modificare i campi o accedere ai layer/tabelle correlati",
      "description": "Descrizione",
      "descriptionTip": "Descrizione: opzione per immettere testo da visualizzare sopra la pagina dell'attributo.",
      "relationTip": "Visualizza layer e tabelle correlati"
    },
    "editFieldError": "Modifiche campo e attributi Smart non sono disponibili per layer non modificabili",
    "noConfigedLayersError": "Smart Editor richiede uno o più layer modificabili",
    "toleranceErrorMsg": "Valore di tolleranza intersezione predefinita non valida",
    "pixelsToleranecErrorMsg": "Valore di tolleranza pixel predefinita non valida",
    "invalidMaxCharacterErrorMsg": "Valore non valido nel passare all'input multilineare"
  },
  "editDescriptionPage": {
    "title": "Definire il testo panoramica attributo per ${layername} "
  },
  "fieldsPage": {
    "title": "Configurare i campi per ${layername}",
    "copyActionTip": "Azioni attributo",
    "editActionTip": "Azioni smart",
    "description": "Usare il pulsante di modifica delle azioni per attivare gli attributi Smart in un layer. Gli attributi Smart possono richiedere, nascondere o disabilitare un campo in base ai valori di altri campi. Usare il pulsante di copia delle azioni per attivare e definire l'origine del valore del campo per intersezione, indirizzo, coordinate o valore preimpostato.",
    "fieldsNotes": "* è un campo obbligatorio. Se si deseleziona Visualizza per questo campo, e il modello di modifica non compila il valore del campo, non sarà possibile salvare un nuovo record.",
    "smartAttachmentText": "Configurare l'azione degli allegati Smart",
    "smartAttachmentPopupTitle": "Configura allegati Smart per ${layername}",
    "fieldsSettingsTable": {
      "display": "Visualizza",
      "displayTip": "Visualizza: determinare se il campo è non visibile",
      "edit": "Modificabile",
      "editTip": "Modificabile: verificare se il campo è presente nel modulo attributo",
      "fieldName": "Nome",
      "fieldNameTip": "Nome: nome del campo definito nel database",
      "fieldAlias": "Alias",
      "fieldAliasTip": "Alias: nome del campo definito nella mappa",
      "canPresetValue": "Preimpostato",
      "canPresetValueTip": "Preimpostato: opzione per visualizzare il campo nell'elenco dei campi preimpostati e consentire all'utente di impostare il valore prima della modifica",
      "actions": "Azioni",
      "actionsTip": "Azioni: modificare l'ordine dei campi o impostare attributi smart"
    },
    "smartAttSupport": "Gli attributi Smart non sono supportati su campi di database obbligatori"
  },
  "actionPage": {
    "title": "Configura le azioni attributo per ${fieldname}",
    "smartActionTitle": "Configurare le azioni attributo Smart per ${fieldname}",
    "description": "Le azioni sono sempre disattivate a meno che non venga specificato il criterio in base al quale vengono attivate. Le azioni vengono elaborate in ordine e verrà attivata una sola azione per campo. Utilizzare il pulsante Modifica criterio per definire il criterio.",
    "copyAttributesNote": "La disattivazione di qualsiasi azione con un nome gruppo sarà uguale alla modifica dell'azione in modo indipendente e rimuoverà l'azione per questo campo dal rispettivo gruppo.",
    "searchPlaceHolder": "Cercare",
    "expandAllLabel": "Espandi tutti i layer",
    "domainListTitle": "Campi del dominio",
    "actionsSettingsTable": {
      "rule": "Azione",
      "ruleTip": "Azione: azione eseguita quando il criterio è soddisfatto",
      "expression": "Espressione",
      "expressionTip": "Espressione: l'espressione risultante in formato SQL dei criteri definiti",
      "groupName": "Nome gruppo",
      "groupNameTip": "Nome gruppo: visualizza il nome gruppo da cui si applica l'espressione",
      "actions": "Criteri",
      "actionsTip": "Criteri: modificare l'ordine della regola e definire i criteri quando viene attivata"
    },
    "copyAction": {
      "description": "L'origine del valore del campo viene elaborata in ordine se attivata finché non si attiva un criterio valido o non viene completato l'elenco. Utilizzare il pulsante di modifica dei criteri per definire i criteri.",
      "intersection": "Intersezione",
      "coordinates": "Coordinate",
      "address": "Indirizzo",
      "preset": "Preimpostato",
      "actionText": "Azioni",
      "criteriaText": "Criteri",
      "enableText": "Abilitata"
    },
    "actions": {
      "hide": "Nascondi",
      "required": "Richiesto",
      "disabled": "Disabilitato"
    },
    "editOptionsPopup": {
      "editAttributeGroupHint": "Avviso: la modifica in modo indipendente rimuoverà l'azione attributo associata per questo campo dal gruppo",
      "editGroupHint": "Avviso: la modifica in modo indipendente rimuoverà l'azione smart associata per questo campo dal gruppo",
      "popupTitle": "Scegli opzioni di modifica",
      "editAttributeGroup": "L'azione attributo selezionata è definita dal gruppo. Scegliere una delle seguenti opzioni per modificare l'azione attributo:",
      "expression": "L'espressione dell'azione smart selezionata è definita dal gruppo. Scegliere una delle seguenti opzioni per modificare l'espressione azione smart:",
      "editGroupButton": "Modifica gruppo",
      "editIndependentlyButton": "Modificare in maniera indipendente"
    }
  },
  "filterPage": {
    "submitHidden": "Inviare dati attributo per i campi anche quando sono nascosti",
    "title": "Configura espressione per la regola ${action}",
    "filterBuilder": "Impostare azione su campo quando il record corrisponde a ${any_or_all} delle seguenti espressioni",
    "noFilterTip": "Utilizzando gli strumenti sottostanti, definire l'istruzione per quando l'azione è attiva."
  },
  "geocoderPage": {
    "setGeocoderURL": "Imposta URL geocodificatore",
    "hintMsg": "Nota: si sta modificando il servizio di geocodifica, assicurarsi di aggiornare il mapping dei campi del geocoder che sono stati configurati.",
    "invalidUrlTip": "URL ${URL} non valida o non accessibile."
  },
  "addressPage": {
    "popupTitle": "Indirizzo",
    "checkboxLabel": "Ottieni valore dal Geocoder",
    "selectFieldTitle": "Attributo",
    "geocoderHint": "Per modificare la configurazione del Geocoder, usare il pulsante "Impostazioni Geocoder" nelle impostazioni generali",
    "prevConfigruedFieldChangedMsg": "L'attributo previamente configurato non è stato trovato nelle impostazioni correnti del geocoder. L'attributo è stato ripristinato al valore predefinito."
  },
  "coordinatesPage": {
    "popupTitle": "Coordinate",
    "checkboxLabel": "Ottieni coordinate",
    "coordinatesSelectTitle": "Sistema di coordinate",
    "coordinatesAttributeTitle": "Attributo",
    "mapSpatialReference": "Riferimento spaziale della mappa",
    "latlong": "Latitudine/Longitudine",
    "allGroupsCreatedMsg": "Tutti i gruppi possibili sono già stati creati"
  },
  "presetPage": {
    "popupTitle": "Preimpostato",
    "checkboxLabel": "Il campo sarà impostato con un valore preimpostato",
    "showOnlyDomainFields": "Mostrare solo i campi di dominio",
    "hideInPresetDisplay": "Nascondere la visualizzazione del valore preimpostato",
    "presetValueLabel": "Il valore preimpostato attuale è:",
    "changePresetValueHint": "Per modificare il valore preimpostato, fare clic sul pulsante "Definisci valori preimpostati" nelle impostazioni generali"
  },
  "intersectionPage": {
    "groupNameLabel": "Nome gruppo",
    "dataTypeLabel": "Tipo di dati",
    "ignoreLayerRankingCheckboxLabel": "Ignora classifica layer e trova la feature più vicina in tutti i layer definiti",
    "intersectingLayersLabel": "Layer per estrarre un valore",
    "layerAndFieldsApplyLabel": "Layer e campi per applicare il valore estratto",
    "checkboxLabel": "Ottieni valore dal campo di intersezione del layer",
    "layerText": "Layer",
    "fieldText": "Campi",
    "actionsText": "Azioni",
    "toleranceSettingText": "Impostazioni di tolleranza",
    "addLayerLinkText": "Aggiungi un layer",
    "useDefaultToleranceText": "Usa tolleranza predefinita",
    "toleranceValueText": "Valore di tolleranza",
    "toleranceUnitText": "Unità tolleranza",
    "pixelsUnitText": "Pixel",
    "useLayerName": "- Usa nome layer -",
    "noLayersMessage": "Nessun campo trovato nei layer della mappa che corrisponda al tipo di dati selezionato."
  },
  "presetAll": {
    "popupTitle": "Definisci valori preimpostati predefiniti",
    "deleteTitle": "Cancella valore preimpostato",
    "hintMsg": "Tutti i nomi di campo univoci preimpostati sono elencati qui. La rimozione di un campo preimpostato disabiliterà il campo rispettivo come preimpostazione da tutti i layer/tabelle."
  },
  "intersectionTolerance": {
    "intersectionTitle": "Tolleranza di intersezione predefinita per tutte le feature.",
    "pixelsToleranceTitle": "Tolleranza di intersezione predefinita (valore pixel) da applicare solo per feature puntuali."
  },
  "smartActionsPage": {
    "smartActionLabel": "Configurare Smart Action",
    "addNewSmartActionLinkText": "Aggiungi nuova",
    "definedActions": "Azioni definite",
    "priorityPopupTitle": "Imposta priorità azioni smart",
    "priorityPopupColumnTitle": "Azioni smart",
    "priorityOneText": "1",
    "priorityTwoText": "2",
    "priorityThreeText": "3",
    "groupNameLabel": "Nome gruppo",
    "layerForExpressionLabel": "Layer per espressione",
    "layerForExpressionNote": "Nota: i campi del layer selezionato verranno utilizzati per definire criteri",
    "expressionText": "Espressione",
    "editExpressionLabel": "Modifica espressione",
    "layerAndFieldsApplyLabel": "Layer e campi da applicare su",
    "submitAttributeText": "Inviare dati attributo per i campi anche quando sono nascosti",
    "priorityColumnText": "Priorità",
    "requiredGroupNameMsg": "Valore obbligatorio.",
    "uniqueGroupNameMsg": "Immettere nome di gruppo univoco. Esiste già un gruppo con questo nome.",
    "deleteGroupPopupTitle": "Elimina gruppo azione smart",
    "deleteGroupPopupMsg": "L'eliminazione del gruppo comporterà la rimozione dell'espressione da tutte le azioni dei campi associate.",
    "invalidExpression": "L'espressione non può essere vuota",
    "warningMsgOnLayerChange": "L'espressione definita e i campi a cui è applicata verranno cancellati.",
    "smartActionsTable": {
      "name": "Nome",
      "expression": "Espressione",
      "definedFor": "Definito per"
    }
  },
  "attributeActionsPage": {
    "name": "Nome",
    "type": "Tipo",
    "deleteGroupPopupTitle": "Elimina gruppo azione attributo",
    "deleteGroupPopupMsg": "L'eliminazione del gruppo comporterà la rimozione dell'azione attributo da tutti i campi associati.",
    "alreadyAppliedActionMsg": "Azione ${action} già applicata a questo campo."
  },
  "chooseFromLayer": {
    "fieldLabel": "Campo",
    "valueLabel": "Valore",
    "selectValueLabel": "Seleziona valore"
  },
  "presetPopup": {
    "presetValueLAbel": "Valore preimpostato"
  },
  "dataType": {
    "esriFieldTypeString": "Stringa",
    "esriFieldTypeInteger": "Numero",
    "esriFieldTypeDate": "Data",
    "esriFieldTypeGUID": "GUID"
  },
  "relativeDates": {
    "dateTypeLabel": "Tipo di data",
    "valueLabel": "Valore",
    "fixed": "Fisso",
    "current": "Corrente",
    "past": "Passato",
    "future": "Futuro",
    "popupTitle": "Seleziona valore",
    "hintForFixedDateType": "Suggerimento: la data e l'ora specificata verranno utilizzate come valore predefinito preimpostato",
    "hintForCurrentDateType": "Suggerimento: la data e l'ora attuali verranno utilizzate come valore predefinito preimpostato",
    "hintForPastDateType": "Suggerimento: il valore specificato verrà sottratto dalla data e l'ora correnti per il valore predefinito della preimpostazione.",
    "hintForFutureDateType": "Suggerimento: il valore specificato verrà aggiunto alla data e l'ora correnti per il valore predefinito della preimpostazione.",
    "noDateDefinedTooltip": "Non è stata definita nessuna data",
    "relativeDateWarning": "È necessario specificare un valore per la data o per l'ora per poter salvare il valore preimpostato predefinito."
  },
  "relativeDomains": {
    "fieldSetTitle": "Elenco",
    "valueText": "Valore",
    "defaultText": "Predefinito",
    "selectedDomainFieldsHint": "Campi di dominio selezionati: ${domainFields}",
    "selectDefaultDomainMsg": "Selezionare un dominio valore predefinito o assicurarsi che la casella di controllo del dominio valore predefinito sia spuntata"
  }
});


text:
{{item.lastName}}   {{item.firstName}}

{{item.department}}

{{item.cellPhone}}

{{item.email}}

        {{item.tags}}
        {{item.tags}}
        {{item.tags}}
        {{item.tags}}
        {{item.tags}}
        {{item.tags}}

            <button class="btn btn-danger btn-xs" ng-click="delete({item: item})" data-toggle="tooltip" data-placement="top" title="Usuń">

            </button>


text:
package ru.job4j.loop;

import org.junit.Test;

import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
/**
 * Test.
 * @author Ilya
 * @version 1
 * @since 0.1
 */
public class FactorialTest {
    /**
     * @Test calc.
     */
    @Test
    public void whenCalculateFactorialForZeroThenOne() {
        Factorial factor = new Factorial();
        int res = factor.calc(5);
        assertThat(res, is(120));
    }
}


text:
Neutron tries to provide an online interaction between teachers and students.
Teachers can give presence online; create exams; formulate questions; and try others
features.

We still having some glitches that we are working on.

![screenshot_2017-10-12_03-20-07](https://user-images.githubusercontent.com/9410495/31481972-690899ce-aefc-11e7-9e09-c35da9fb4afa.png)

## Prerequisites
```
nodejs v8.6.0 <=
npm
lamp / xampp / wamp
chromium
```
Firefox sometimes presents some instabilities
### Installing

First you should install npm modules
```
npm install
```

Then, just run the app

```
node app.js
```

By now, it should be running in your localhost(usually port:3000) or server.

## Running the tests
We have also created a database for tests .
```
sqe.sql
```
Just import it and you will be able to test our teachers' features
(We have prepared an user)

```
Teacher
ID/Matricula : 10
PassWord     : 123

ADM
ID/Matricula : 25
PassWord     : 123
```

## Main Authors

* **Yuri Medeiros**
* **Matheus Nunes**

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details


text:
<?php
/**
 * Created by PhpStorm.
 * User: karlvaniseghem
 * Date: 25/09/15
 * Time: 12:25
 */

namespace Bakgat\Notos\Domain\Services\Location;

use Bakgat\Notos\Domain\Model\Identity\Name;
use Bakgat\Notos\Domain\Model\Identity\Organization;
use Bakgat\Notos\Domain\Model\Identity\OrganizationRepository;
use Bakgat\Notos\Domain\Model\Location\Blog;
use Bakgat\Notos\Domain\Model\Location\BlogRepository;
use Bakgat\Notos\Domain\Model\Location\URL;

class BlogService
{
    /** @var BlogRepository $blogRepo */
    private $blogRepo;
    /** @var OrganizationRepository $orgRepo */
    private $orgRepo;

    public function __construct(BlogRepository $blogRepository, OrganizationRepository $organizationRepository)
    {
        $this->blogRepo = $blogRepository;
        $this->orgRepo = $organizationRepository;
    }

    public function all($orgId)
    {
        /** @var Organization $organization */
        $organization = $this->orgRepo->organizationOfId($orgId);

        return $this->blogRepo->all($organization);
    }

    public function blogOfId($id)
    {
        return $this->blogRepo->blogOfId($id);
    }

    public function add($orgId, $data)
    {

        $organization = $this->orgRepo->organizationOfId($orgId);

        $name = new Name($data['name']);
        $url = new URL($data['url']);
        $description = isset($data['description']) ? $data['description'] : null;

        /** @var Blog $blog */
        $blog = Blog::register($name, $url, $organization);
        $blog->setDescription($description);

        $this->blogRepo->add($blog);
    }

    public function update($id, $data)
    {
        /** @var Blog $blog */
        $blog = $this->blogRepo->blogOfId($id);

        $name = new Name($data['name']);
        $url = new URL($data['url']);
        $description = isset($data['description']) ? $data['description'] : null;

        $blog->setName($name);
        $blog->setURL($url);
        $blog->setDescription($description);

        $this->blogRepo->update($blog);
    }

}


text:
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**message** | **string** | A human-readable message with more details about the error | [optional]
**status_code** | **int** | A conventional HTTP status code. | [optional]
**code** | **string** | A pre-defined string identifying an error. | [optional]

[[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md)


text:
TODO: Usage instructions

## Development

Checkout the repo, then, run `npm run build` to build the project and `npm run lint` to run the CSS linting rules.

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/davidrhyswhite/bento

## License

The module is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).


text:
  'use strict';

var Base = require('./../../base');

module.exports = Base.extend({

  suspendButton: function() {
    return element(by.css('.modal-footer [ng-click="updateSuspensionState()"]'));
  },

  okButton: function() {
    return element(by.css('.modal-footer [ng-click="close(status)"]:not(.ng-hide)'));
  }

});


text:
Before opening an issue, please make do a quick search through the current issues
and the mailing list (https://groups.google.com/forum/#!forum/yeti-users) to see
if it hasn't been answered already.

### Description
[Please provide a description of the issue encountered]

### Environment

| Question         | Answer
|------------------|--------------------
| Git commit       | Type `$ git log | head -n1` to find out
| OS version       | Ubuntu 16.04, Windows 10, macOS 10.12.3
| Browser          | Chrome 56.0.2924.87

### Steps to Reproduce
1. git clone the repo
1. cd yeti
1. pip install -r
1. observe stacktrace

#### Expected behavior
[How are you expecting the application to behave?]

#### Actual behavior
[How is the application behaving? (include any stacktraces, logs, screenshots, etc.)]


text:
import java.io.Serializable;

public class PongUpdate implements Serializable
{
	public boolean serverUpdate = false;
	public double ballX = 0, ballY = 0;
	public int playerY = 0, player1p = 0, player2p = 0;
	public PongUpdate(double bX, double bY, int pY, int p1p, int p2p)
	{
		ballX = bX;
		ballY = bY;
		playerY = pY;
		player1p = p1p;
		player2p = p2p;
	}

	public PongUpdate(int pY)
	{
		serverUpdate = true;
		playerY = pY;
	}
}


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Syn. fl. germ. helv. 154. 1836 ("1835")

#### Original name
null

### Remarks
null


text:
function[mapdata] = unzip_shape(z_n,varargin)
% unzip_shape -- `Unzips' a shape via a zipper-type algorithm
%
% [mapdata] = unzip_shape(z_n,{z_in=false,w_in=false,
%                 z_out=false, w_out=false, winding_number=1,
%                 zip_magnitude=0.85, type='geodesic', M=30})
%
%     The main workhorse routine for computing a welding map of a shape.
%
%     Output mapdata contains:
%            a_array
%            moebius_maps
%            z_in
%            w_in
%            z_out
%            w_out
%            vertices_in
%            vertices_out
%            type
%
%     The output mapdata contains all the necessary information for travelling
%     back and forth on the conformal map defined by the shape's vertices z_n
%     and their corresponding inner and outer values on the unit circle,
%     vertices_in and vertices_out.
%
%     This is the main work file for zipper-type algorithms from [1]. The 'base'
%     map may be interchanged to form the 'geodesic', 'slit', and 'zipper'
%     algorithms.
%
%     The map takes z_in (inside the original shape) to w_in (inside the unit
%     circle). If z_in is specified without w_in, then w_in is assumed to be 0.
%     If neither z_in nor w_in is specified, no interior Moebius transform is
%     performed.
%
%     The map takes z_out (outside the original shape) to w_out (outside the
%     unit circle.) If z_out is specified without w_out, then w_out is assumed
%     to be infinity. If neither z_out nor w_out is specified, the map takes
%     infinity to infinity.
%
%     The winding_number determines the orientation of the input data with
%     respect to the shape.
%
%     The option zip_magnitude refers to how each 'base' map is normalized.
%     Empirically, values O(1) produce stable results.
%
%     The option M is the number of sub-steps that a predictive Loewner solver
%     takes between each shape vertex.
%
%     The `type' of mapping can be: 'geodesic', 'slit', 'zipper', or 'loewner'.
%
%     A note on normalization: this function normalizes the interior and
%     exterior moebius maps so that the first vertex of the shape lies at the
%     mapped point z=1 (both interior and exterior).
%
%     [1]: Marshall and Rohde, "Convergence of the Zipper algorithm for
%          conformal mapping", 2006.

persistent input_schema zip moebius visualize
persistent initial_map terminal_map assert_enough_points select_unzipper moebius_alignment

if isempty(input_schema)
  from labtools import input_schema
  from shapelab.common import moebius
  from shapelab.zipper import assert_enough_points
  from shapelab.zipper import select_unzipper
  from shapelab.zipper.drivers import visualize
  from shapelab.zipper.drivers import calculate_initial_map as initial_map
  from shapelab.zipper.drivers import calculate_terminal_map as terminal_map
  from shapelab.zipper.drivers import calculate_moebius_alignment as moebius_alignment
end

inputs = {'z_in', 'w_in', 'z_out', 'w_out', 'winding_number',...
          'zip_magnitude','type','visualize', 'M'};
defaults = {[], [], Inf, Inf, 1, 0.85, 'geodesic',false, 30};
opt = input_schema(inputs,defaults,[],varargin{:});

mapdata.w_out = opt.w_out;
mapdata.w_in = opt.w_in;
mapdata.z_in = opt.z_in;
mapdata.z_out = opt.z_out;
mapdata.winding_number = opt.winding_number;
mapdata.type = opt.type;
mapdata.tooth_length = opt.zip_magnitude;
mapdata.M = opt.M;

moebius_maps.H_to_D = [-1, i; ...
                        1, i];  % Just a map from half plane to unit circle.

% Some initial computations, making sure we have enough points, and append some
% more points
if isempty(opt.z_in)
  [N, N_teeth, z_n] = assert_enough_points(z_n, opt.type, opt.z_out, mean(z_n), z_n(1));
else
  [N, N_teeth, z_n] = assert_enough_points(z_n, opt.type, opt.z_out, opt.z_in, z_n(1));
end

% Now length(z_n) == N+3
[z_n, mapdata] = initial_map(z_n, opt.type, mapdata);

w_n = z_n;
% z_n are the 'exterior' points, and w_n are the interior points

visdata = initialize_visualization();
visdata.visualize = opt.visualize;

%% Initialization for looping over teeth
unzip = select_unzipper(opt.type);

% Loop over teeth:
for q = 1:N_teeth
  [w_n, z_n, mapdata] = unzip(q, z_n, w_n, mapdata);
  visualize(z_n(q+2:end-3), w_n(1:q+2), z_n(1:q+2), visdata);
end

[w_n, z_n, mapdata] = terminal_map(w_n, z_n, mapdata);

[w_n, z_n, mapdata] = moebius_alignment(w_n, z_n, mapdata);

% Done
mapdata.vertices_in = w_n(1:end-3);
mapdata.vertices_out = z_n(1:end-3);

  function[visdata]=initialize_visualization()
    if opt.visualize
      figure();
      theta = linspace(0,2*pi,200);
      plot(exp(i*theta), 'b--');
      axis square;
      axis off;
      hold on;
      shape_plot = plot(moebius(z_n, moebius_maps.H_to_D), 'k.-');
      temp = moebius([Inf; 0],moebius_maps.H_to_D);
      zin_plot = plot(real(temp), imag(temp), 'r.');
      temp = moebius([Inf; 0], moebius_maps.H_to_D);
      zout_plot = plot(real(temp), imag(temp), 'b.');
    else
      shape_plot = 0;
      zin_plot = 0;
      zout_plot = 0;
    end

    visdata.shape_plot = shape_plot;
    visdata.zin_plot = zin_plot;
    visdata.zout_plot = zout_plot;
  end

end


text:
package com.atlassian.pageobjects.elements.query;

import org.hamcrest.StringDescription;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;

/**
 * Abstract implementation of the {@link PollingQuery} interface.
 *
 */
public class AbstractPollingQuery implements PollingQuery
{
    protected final long interval;
    protected final long defaultTimeout;

    protected AbstractPollingQuery(long interval, long defaultTimeout)
    {
        checkArgument(interval > 0, new StringDescription().appendText("interval is ").appendValue(interval)
                .appendText(" should be > 0").toString());
        checkArgument(defaultTimeout > 0, new StringDescription().appendText("defaultTimeout is ").appendValue(defaultTimeout)
                .appendText(" should be > 0").toString());
        checkArgument(defaultTimeout >= interval, new StringDescription().appendText("defaultTimeout is ").appendValue(defaultTimeout)
                .appendText(" interval is ").appendValue(interval).appendText(" defaultTimeout should be >= interval").toString());
        this.interval = interval;
        this.defaultTimeout = defaultTimeout;
    }

    protected AbstractPollingQuery(PollingQuery other)
    {
        this(checkNotNull(other, "other").interval(), other.defaultTimeout());
    }

    public long interval()
    {
        return interval;
    }

    public long defaultTimeout()
    {
        return defaultTimeout;
    }
}


text:
require 'json'

data = JSON.parse(ARGF.read)

preload = {}

data['hosting']['headers'].each do |header|
  source = header['source']
  link = header['headers'].find { |h| h['key'] == 'Link' }
  continue unless link
  links = link['value'].split(',')
  links_for_url = preload[source] ||= []
  links.each { |l| links_for_url << l.match(/<([^>]+)>/)[1] }
end

puts JSON.dump(preload)


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="app_name">CoolWeather</string>
    <string name="hello_world">Hello world!</string>
    <string name="action_settings">Settings</string>
    <string name="switchCity">switch city</string>
    <string name="refreshWeather">refresh weather</string>

</resources>


text:
Morpher::Engine.routes.draw do
end


text:
namespace content {

// A human-readable summary phrase and more detailed description of a
// security property that was used to compute the SecurityStyle of a
// resource. An example summary phrase would be "Expired Certificate",
// with a description along the lines of "This site's certificate chain
// contains errors (net::CERT_DATE_INVALID)".
struct SecurityStyleExplanation {
  CONTENT_EXPORT SecurityStyleExplanation(){};
  CONTENT_EXPORT SecurityStyleExplanation(const std::string& summary,
                                          const std::string& description)
      : summary(summary), description(description), cert_id(0) {}
  CONTENT_EXPORT SecurityStyleExplanation(const std::string& summary,
                                          const std::string& description,
                                          int cert_id)
      : summary(summary), description(description), cert_id(cert_id) {}
  CONTENT_EXPORT ~SecurityStyleExplanation() {}

  std::string summary;
  std::string description;
  int cert_id;
};

}  // namespace content

#endif  // CONTENT_PUBLIC_BROWSER_SECURITY_STYLE_EXPLANATION_H_


text:
package com.mysql.binlog.event;

/**
 * @author Patrick Prasse
 */
public class GtidEventData implements EventData {

    public static final byte COMMIT_FLAG = 1;

    private String gtid;
    private byte flags;

    public String getGtid() {
        return gtid;
    }

    public void setGtid(String gtid) {
        this.gtid = gtid;
    }

    public byte getFlags() {
        return flags;
    }

    public void setFlags(byte flags) {
        this.flags = flags;
    }

    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("GtidEventData");
        sb.append("{flags=").append(flags).append(", gtid='").append(gtid).append('\'');
        sb.append('}');
        return sb.toString();
    }

}