text:
body {
	min-height:640px;
	font-family:Comic Sans MS, Comic Sans, Chalkboard, Helvetica, Arial, sans-serif;
	overflow:hidden;
}
.bg {
	z-index:-2;
	background-color: lightblue;
	background-repeat:  no-repeat;
	background-position: center center;
	background-attachment: fixed;
	-webkit-background-size: cover;
	-moz-background-size: cover;
	-o-background-size: cover;
	background-size: cover;
}
.container {
	width:550px;
	height:640px;
	position:absolute;
	top:50%;
	left: 50%;
	margin-left:-275px;
	margin-top: -320px;
}
.doge-image {
	width:550px;
	height:550px;
	z-index:-1;
	background: url(img/doge/doge-regular.png);
	background-repeat: no-repeat;
	background-attachment: center center;
	background-size: 550px 550px;
}
#all-cycle {
	height:90px;
	position:relative;
	top:-100px;
	text-align: center;
}
#cycle-desc {
	font-weight: bold;
	font-size: 40px;
	color:#33D6FF;
	text-transform: lowercase;
}
#cycle-day {
	font-size: 25px;
	color: #ff3399;
}
#cycle-avg {
	font-size: 20px;
	color: #30FFD6;
}
.t {
	color: #30FFD6;
	display: inline-block;
}
.suchlikes {
	display: block;
	padding: 10px;
}
.much-like {
	display: inline-block;
	padding: 5px;
}
.ourinfo {
	display:block;
	position:absolute;
	bottom:0;
	right:0;
	padding:0 10px 10px 0;
	color: #ffffe6;
	font-weight: 100px;
	font-size: 10px;
	letter-spacing: 1px;
	text-align:right;
}
.ourinfo p {
	margin: 0;
	padding:0;
}
.ourinfo a {
	text-decoration: none;
	color:#FFFF99;
	font-weight: bold;
}
.ourinfo a:hover {
	color: #FF3399;
}
.login_input, .styled_input {
	/* http://code.tiffbits.com/css3-form-styling-cheat-sheet/ */
	padding: 2px;
	font-family:Comic Sans MS, Comic Sans, Chalkboard, Helvetica, Arial, sans-serif;
	border:solid 1px #ccc;
	-webkit-border-radius: 3px;
	-moz-border-radius: 3px;
	border-radius: 3px;
}
.styled-button {
	/* http://graemeboy.com/css-buttons/ */
	background:#f78096;
	background:-moz-linear-gradient(top,#f78096 0%,#f56778 100%);
	background:-webkit-gradient(linear,left top,left bottom,color-stop(0%,#f78096),color-stop(100%,#f56778));
	background:-webkit-linear-gradient(top,#f78096 0%,#f56778 100%);
	background:-o-linear-gradient(top,#f78096 0%,#f56778 100%);
	background:-ms-linear-gradient(top,#f78096 0%,#f56778 100%);
	background:linear-gradient(top,#f78096 0%,#f56778 100%);
	filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#f78096',endColorstr='#f78096',GradientType=0);
	padding:4px 7px;
	color:#fff;
	font-family:Comic Sans MS, Comic Sans, Chalkboard, Helvetica, Arial, sans-serif;
	font-size:12px;
	border-radius:4px;
	-moz-border-radius:4px;
	-webkit-border-radius:4px;
	border:1px solid #ae4553;
}
.styled-button:hover, .styled-button:focus {
	background: #de7387;
}
.padded_right {
	padding-right: 40px;
}
#login_form, #registration_form, #options  {
	padding-top: 8px;
}
#such_options {
	cursor:pointer;
	width:auto;
	position:absolute;
	font-size:15px;
	top:0px;
	padding:14px 15px 14px 30px;
	right:0px;
	text-align:right;
	color: #FFFF75;
	background-color:rgba(0,0,0,0.2);
	background-image:url('./img/doge-geo.png');
	background-position: right top;
	background-repeat: no-repeat;
	background-size:38px 38px;
}
#such_options a {
	color: #FFFF75;
	text-decoration: none;
}
#such_options a:hover {
	color:#FF5CFF;
}
#feedback {
	font-style: italic;
	font-size: 12px;
	padding-top: 5px;
}
#suchsecrets {
	display: none;
}


text:
package com.forgedui.swt.dialogs;

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

public class FileSystemImages extends ImagesResource {

	public FileSystemImages() {
		super();
	}

	static public ISourceImage[] getFileImageSources(File file) {
		if (file == null)
			return null;
		List<FileImageSource> fileList = new ArrayList<FileImageSource>();
		File files[] = file.listFiles();
		if (files != null && files.length > 0) {
			for (int i = 0; i < files.length; i++) {
				if (!files[i].getName().startsWith(".")) {
					fileList.add(new FileImageSource(files[i]));
				}
			}
			return fileList.toArray(new ISourceImage[fileList.size()]);
		} else {
			return null;
		}
	}
}

redpajama_set_name: RedPajamaGithub


text:
package ru.stqa.pft.addressbook.tests;

import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import ru.stqa.pft.addressbook.model.ContactData;
import ru.stqa.pft.addressbook.model.Contacts;

import java.io.File;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;

public class ContactModificationTests extends TestBase {
    @BeforeMethod
    public void ensurePreconditions() {
        File photo = new File("src/test/resources/avatar.jpg");
        if (app.db().contacts().size() == 0) {
            app.goTo().contactPage();
            app.contact().create(new ContactData().withFirstName("FirstNameForModification")
                    .withLastName("LastNameForModification").withMobilePhone("+380634873365").withWorkPhone("+380448764561")
                    .withPhoto(photo));
        }
    }

    @Test
    public void testContactModification() {
        Contacts before = app.db().contacts();
        ContactData modifiedContact = before.iterator().next();
        ContactData contact = new ContactData().withId(modifiedContact.getId()).withFirstName("UpdatedFirst")
                .withLastName("UpdatedLast").withBirthDate("28").withBirthMonth("May").withBirthYear("1877");

        app.contact().modify(contact);

        assertThat(app.contact().count(), equalTo(before.size()));
        Contacts after = app.db().contacts();
        assertThat(after, equalTo(before.without(modifiedContact).withAdded(contact)));
        verifyContactListInUI();
    }
}


text:
requirejs.config({
  //By default load any module IDs from js/lib
  baseUrl: '/static/js/lib',

  //except, if the module ID starts with "app",
  //load it from the js/app directory. paths
  //config is relative to the baseUrl, and
  //never includes a ".js" extension since
  //the paths config could be for a directory.
  paths: {
    summary: '../summary',
    study: '../study'
  },

  shim: {
    'backbone': {
      //These script dependencies should be loaded before loading
      //backbone.js
      deps: ['underscore', 'jquery'],
      //Once loaded, use the global 'Backbone' as the
      //module value.
      exports: 'Backbone'
    },
    'underscore': {
      exports: '_'
    },
    'jquery': {
      exports: '$'
    },
    'handlebars': {
      exports: 'Handlebars'
    },
    'bootstrap': {
      deps: ['jquery'],
      exports: '$'
    },
    'bootstrap-slider': {
      deps: ['bootstrap'],
      exports: '$'
    },
    'tether': {
      exports: 'Tether'
    },
    'shepherd': {
      deps: ['jquery', 'tether', 'backbone'],
      exports: 'Shepherd'
    }
  }
});

// Start the main app logic.
requirejs(['jquery',
           'd3',
           'summary/util',
           'study/setup',
           'summary/task',
           'underscore',
           'shepherd',
           'handlebars',
           'bootstrap',
           'bootstrap-slider'
  ], function ($, d3, util, setup, TaskView, _, Shepherd, Handlebars) {
  $ = require('bootstrap-slider');

  var testq1 = {
    x: 'day',
    ys: [{col: 'amt', expr: 'avg(amt)'}],
    schema: {
      x: 'num',
      amt: 'num'
    },
    table: 'hard2',
    db: 'test'
  };

  var taskprefix = "task12-"+window.enableScorpion+"-";

  var tour = setup.setupAvg(testq1, taskprefix, window.jsidx);
  tour.start();
  window.tour = tour;

});


text:
from datetime import datetime

from django.conf import settings
from django.template.loader import render_to_string
from django.utils.timezone import now

from remo.base.tasks import send_remo_mail
from remo.base.utils import get_date
from remo.reports.models import NGReport

def count_user_ng_reports(user, current_streak=False,
                          longest_streak=False, period=0):
    """Return the number of reports of a user over

    a period of time. If current_streak is True return the
    current streak of a user. Arg period expects weeks
    eg 2 means 2 * 7 = 14 days.
    """
    end_period = now()
    start_period = datetime(2011, 01, 01)

    if current_streak:
        start_period = user.userprofile.current_streak_start
    elif longest_streak:
        start_period = user.userprofile.longest_streak_start
        end_period = user.userprofile.longest_streak_end
    elif period > 0:
        start_period = get_date(-(period * 7))

    query = user.ng_reports.filter(report_date__range=(start_period,
                                                       end_period))

    return query.count()

def get_last_report(user):
    """Return user's last report in the past."""
    today = now().date()

    try:
        reports = user.ng_reports.filter(report_date__lte=today)
        return reports.latest('report_date')
    except NGReport.DoesNotExist:
        return None

def send_report_notification(reps, weeks):
    """Send notification to inactive reps."""
    rep_subject = '[Reminder] Please share your recent activities'
    rep_mail_body = 'emails/reps_ng_report_notification.jinja'
    mentor_subject = ('[Report] Mentee without report for the last %d weeks'
                      % weeks)
    mentor_mail_body = 'emails/mentor_ng_report_notification.jinja'

    for rep in reps:
        mentor = rep.userprofile.mentor
        ctx_data = {'mentor': mentor,
                    'user': rep,
                    'SITE_URL': settings.SITE_URL,
                    'weeks': weeks}

        rep_message = render_to_string(rep_mail_body, ctx_data)
        mentor_message = render_to_string(mentor_mail_body, ctx_data)
        if mentor:
            send_remo_mail(subject=rep_subject, recipients_list=[rep.email],
                           sender=mentor.email, message=rep_message)
            send_remo_mail(subject=mentor_subject,
                           recipients_list=[mentor.email],
                           sender=rep.email,
                           message=mentor_message)
        else:
            send_remo_mail(rep_subject, [rep.email], message=rep_message)


text:
/* DO NOT MODIFY. This file was compiled Tue, 26 Jul 2011 23:13:00 GMT from
 * /Work/congressconnect/app/coffeescripts/call.coffee
 */

var call;
Twilio.Device.ready = function(device) {
  return $("#log").text("Ready");
};
Twilio.Device.error = function(error) {
  return $("#log").text("Error: " + error.message);
};
Twilio.Device.connect = function(conn) {
  return $("#log").text("Successfully established call");
};
call = function() {
  return Twilio.Device.connect();
};


text:
package view.Toolbar;

import java.util.List;
import java.util.function.BiConsumer;

import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;

/**
 * Class that allows users to select a turtle image from a choice box.
 *
 * @author DavidTran
 *
 */
public class TurtleImageOptionView extends OptionView {

	private List<String> imageNameList;
	private static final String PROMPT = "TurtleImagePrompt";
	private BiConsumer<String, String> myCommandConsumer;

	public TurtleImageOptionView(List<String> imgList, BiConsumer<String, String> commandConsumer) {

		super(PROMPT);

		imageNameList = imgList;
		myCommandConsumer = commandConsumer;

		for (String imageName : imageNameList) {
			cb.getItems().add(imageNameList.indexOf(imageName) + ". " + imageName);
		}

		cb.getSelectionModel().selectedIndexProperty().addListener(new ChangeListener<Number>() {

			@Override
			public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
				myCommandConsumer.accept("SetShape", Integer.toString(newValue.intValue()));
			}
		});
	}

}


text:
from datetime import timedelta
from unittest import TestCase

import pytest
from testfixtures import log_capture

from keepercommander.commands.helpers.timeout import (
    enforce_timeout_range, format_timeout, get_delta_from_timeout_setting, get_timeout_setting_from_delta, parse_timeout
)
from keepercommander.constants import TIMEOUT_DEFAULT

@pytest.mark.parametrize(
    'time_input,expected',
    [
        ('3', timedelta(minutes=3)),
        ('1d2h3m', timedelta(days=1, hours=2, minutes=3)),
        ('4 minutes 5 hours 6 days', timedelta(days=6, hours=5, minutes=4))
    ]
)
def test_parse_timeout(time_input, expected):
    assert parse_timeout(time_input) == expected

@pytest.mark.parametrize(
    'timeout_delta,expected',
    [
        (timedelta(), '0'),
        (timedelta(minutes=3), '3 minutes'),
        (timedelta(days=1, hours=2, minutes=3), '1 day, 2 hours, 3 minutes'),
        (timedelta(days=6, hours=5, minutes=4), '6 days, 5 hours, 4 minutes')
    ]
)
def test_format_timeout(timeout_delta, expected):
    assert format_timeout(timeout_delta) == expected

class TestParseTimeout(TestCase):
    def test_parse_timeout_invalid(self):
        time_input = '3 invalidunits'
        with self.assertRaises(ValueError):
            parse_timeout(time_input)

class TestEnforceTimeoutRange(TestCase):
    @log_capture()
    def test_less_than_min(self, capture):
        timeout_delta = timedelta(0)
        expect_delta = TIMEOUT_DEFAULT
        expect_warning = 'The minimum device timeout value is 1 minute. The device timeout has been set to the default Keeper timeout value.'

        new_timeout_delta = enforce_timeout_range(timeout_delta)
        self.assertEqual(expect_delta, new_timeout_delta)
        capture.check(('root', 'WARNING', expect_warning))

class TestTimeoutSetting(TestCase):
    def test_get_timeout_setting_from_delta(self):
        timeout_delta = timedelta(minutes=20000)
        expect_setting = '20000'

        self.assertEqual(expect_setting, get_timeout_setting_from_delta(timeout_delta))

    def test_get_delta_from_timeout_setting(self):
        # 10000 (minutes) * 60000 (milliseconds per minute)
        timeout_setting = '600000000'
        expect_delta = timedelta(minutes=10000)

        self.assertEqual(expect_delta, get_delta_from_timeout_setting(timeout_setting))


text:
var ProfileDAO = require("../data/profile-dao").ProfileDAO;

/* The ProfileHandler must be constructed with a connected db */
function ProfileHandler(db) {
    "use strict";

    var profile = new ProfileDAO(db);

    this.displayProfile = function(req, res, next) {
        var userId = req.session.userId;

        profile.getByUserId(parseInt(userId), function(err, doc) {
            if (err) return next(err);
            doc.userId = userId;

            return res.render("profile", doc);
        });
    };

    this.handleProfileUpdate = function(req, res, next) {

        var firstName = req.body.firstName;
        var lastName = req.body.lastName;
        var ssn = req.body.ssn;
        var dob = req.body.dob;
        var address = req.body.address;
        var bankAcc = req.body.bankAcc;
        var bankRouting = req.body.bankRouting;

        var userId = req.session.userId;

        profile.updateUser(
            parseInt(userId),
            firstName,
            lastName,
            ssn,
            dob,
            address,
            bankAcc,
            bankRouting,
            function(err, user) {

                if (err) return next(err);

                // WARN: Applying any sting specific methods here w/o checking type of inputs could lead to DoS by HPP
                //firstName = firstName.trim();
                //user.updateSuccess = true;
                //user.userId = userId;

                //return res.render("profile", user);
                profile.getByUserId(parseInt(userId), function(err, doc) {
                    if (err) return next(err);
                    doc.userId = userId;
                    doc.updateSuccess = true;
                    return res.render("profile", doc);
                });
            }
        );

    };

}

module.exports = ProfileHandler;


text:
using System.Xml.Serialization;

namespace Xpressive.Home.Plugins.Denon
{
    public class ValueDto
    {
        [XmlElement("value")]
        public string Value { get; set; }
    }
}


text:
class Transform
{
private:
	glm::vec3 pos;
	glm::quat rot;
	glm::vec3 sca;
	glm::mat4 tMat;
public:
	Transform();
	Transform(const glm::vec3& position, const glm::quat& rotation, const glm::vec3& scale);
	Transform(const glm::vec3& position, const glm::vec3& rotation, const glm::vec3& scale);
	inline glm::vec3 GetPosition() const { return pos; }
	inline glm::vec3 GetRotationEulerAngles() const { return glm::degrees(glm::eulerAngles(rot)); }
	inline glm::quat GetRotation() const { return rot; }
	inline glm::vec3 GetScale() const { return sca; }
	inline glm::mat4 GetTransformation() const { return tMat; }
	Transform& SetPosition(glm::vec3& position);
	Transform& SetRotation(glm::vec3& eulerAngles);
	Transform& SetRotation(glm::quat& rotation);
	Transform& SetScale(glm::vec3& scale);
	Transform& Translate(glm::vec3& trans);
	Transform& Rotate(glm::quat& rot);
	Transform& Rotate(glm::vec3& rot);
	Transform& Scale(glm::vec3& sca);
	Transform  TransformLocal(const Transform& local);
	void Reset();
};

#include "transform.cpp"


text:
package com.daxiang.domain.many2many_bi;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.*;
@Entity
public class Student {
	@Id
	@GeneratedValue
	@Column(name="id")
	private int studentid;
	private String firstname;
	private String lastname;
	@ManyToMany(cascade=CascadeType.ALL)
	private List<Course> courses=new ArrayList<Course>();
	public Student() {
		// TODO Auto-generated constructor stub
	}

	public Student(String firstname, String lastname) {
		super();
		this.firstname = firstname;
		this.lastname = lastname;
	}

	public int getStudentid() {
		return studentid;
	}
	public void setStudentid(int studentid) {
		this.studentid = studentid;
	}
	public String getFirstname() {
		return firstname;
	}
	public void setFirstname(String firstname) {
		this.firstname = firstname;
	}
	public String getLastname() {
		return lastname;
	}
	public void setLastname(String lastname) {
		this.lastname = lastname;
	}
	public List<Course> getCourses() {
		return courses;
	}
	public void setCourses(List<Course> courses) {
		this.courses = courses;
	}

}


text:
package Servlet;

import Bean.CloudantClientClass;
import Bean.TexttoSpeechConnector;
import Bean.DashDBConnector;
import Bean.LanguageTranslatorConnector;
import Bean.ObjectStorageConnector;
import com.ibm.watson.developer_cloud.language_translation.v2.LanguageTranslation;
import com.ibm.watson.developer_cloud.language_translation.v2.model.TranslationResult;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.ibm.watson.developer_cloud.text_to_speech.v1.TextToSpeech;
import java.io.InputStream;

import org.openstack4j.model.common.Payload;
import org.openstack4j.model.common.Payloads;

import org.json.simple.parser.JSONParser;
import org.json.simple.JSONObject;

@WebServlet(name = "TexttoSpeechServlet", urlPatterns = {"/TexttoSpeechServlet"})

public class TexttoSpeechServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

			TexttoSpeechConnector connector = new TexttoSpeechConnector();
  			TextToSpeech service = new TextToSpeech();
  			service.setUsernameAndPassword(connector.getUsername(),connector.getPassword());

        		String text = request.getParameter("inputText");
        		String format = "audio/wav";

  				InputStream speech = service.synthesize(text, format);

				ObjectStorageConnector osConnector = new ObjectStorageConnector();
				osConnector.createContainer("containerName");
				 Payload upfile = null;
				 upfile = Payloads.create(speech);
				 osConnector.uploadFile("containerName", "texttospeech.wav", upfile);

			try{

				/*CloudantClientClass db = new CloudantClientClass();

				int addStat;
				addStat = db.addEntry(translatedText);

				DashDBConnector dashdb = new DashDBConnector();

				JSONParser jsonParser = new JSONParser();
				JSONObject jsonObject = (JSONObject) jsonParser.parse(translatedText);
				String product = (String) jsonObject.get("translation");

				dashdb.addWords(product);
				*/

			} catch (Exception e) {
				e.printStackTrace(System.err);
			}

			/*
			String test = connector.getUsername();
			request.setAttribute("outputText",test);
			*/

			response.setContentType("text/html");
			response.setStatus(200);
			request.getRequestDispatcher("langtransindex.jsp").forward(request,response);
        //processRequest(request, response);
    }
/*
    public String test(){
    	LanguageTranslatorConnector connector = new LanguageTranslatorConnector();
    	LanguageTranslation languageTranslation = new LanguageTranslation();
    	languageTranslation.setUsernameAndPassword(connector.getUsername(),connector.getPassword());
    	TranslationResult translated = languageTranslation.translate("hello", "en", "es");
    	String translatedText = translated.toString();

    	return translatedText;
    }
	*/

}


text:
package aoc20;

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

public class Day6 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = 0;
        while (in.hasNextLine()) {
            List<String> response = gatherResponses(in);
            int answers = countAnswers(response);
            sum += answers;
            System.out.println(sum);
        }
    }

    private static int countAnswers(List<String> response) {
        Map<Character, Integer> charCounts = new HashMap<>();
        for (String str : response) {
            for (char c : str.toCharArray()) {
                int count = charCounts.getOrDefault(c, 0);
                charCounts.put(c, count + 1);
            }
        }
        return (int) charCounts.values().stream().filter(c -> c == response.size()).count();
    }

    private static List<String> gatherResponses(Scanner in) {
        List<String> result = new ArrayList<>();
        String line = in.nextLine();
        while (!line.isEmpty()) {
            result.add(line);
            line = in.nextLine();
        }
        return result;
    }
}


text:
<!--

********************************************************************************

WARNING:

    DO NOT EDIT "buildpack-deps/README.md"

    IT IS AUTO-GENERATED

    (from the other files in "buildpack-deps/" combined with a set of templates)

********************************************************************************

-->

# Supported tags and respective `Dockerfile` links

-	[`artful-curl`, `17.10-curl` (*artful/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/artful/curl/Dockerfile)
-	[`artful-scm`, `17.10-scm` (*artful/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/36018aca7e9637c9c04ff623625e59de12d7f161/artful/scm/Dockerfile)
-	[`artful`, `17.10` (*artful/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/d7da72aaf3bb93fecf5fcb7c6ff154cb0c55d1d1/artful/Dockerfile)
-	[`bionic-curl`, `18.04-curl` (*bionic/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/bionic/curl/Dockerfile)
-	[`bionic-scm`, `18.04-scm` (*bionic/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/0db0cf15f1c507b17e7edc6dfbe301b8e357568f/bionic/scm/Dockerfile)
-	[`bionic`, `18.04` (*bionic/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/0db0cf15f1c507b17e7edc6dfbe301b8e357568f/bionic/Dockerfile)
-	[`buster-curl`, `testing-curl` (*buster/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/buster/curl/Dockerfile)
-	[`buster-scm`, `testing-scm` (*buster/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/99a1c33fda559272e9322b02a5d778bbd04154e7/buster/scm/Dockerfile)
-	[`buster`, `testing` (*buster/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/d7da72aaf3bb93fecf5fcb7c6ff154cb0c55d1d1/buster/Dockerfile)
-	[`jessie-curl`, `oldstable-curl` (*jessie/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/jessie/curl/Dockerfile)
-	[`jessie-scm`, `oldstable-scm` (*jessie/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/1845b3f918f69b4c97912b0d4d68a5658458e84f/jessie/scm/Dockerfile)
-	[`jessie`, `oldstable` (*jessie/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/d7da72aaf3bb93fecf5fcb7c6ff154cb0c55d1d1/jessie/Dockerfile)
-	[`sid-curl`, `unstable-curl` (*sid/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/sid/curl/Dockerfile)
-	[`sid-scm`, `unstable-scm` (*sid/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/99a1c33fda559272e9322b02a5d778bbd04154e7/sid/scm/Dockerfile)
-	[`sid`, `unstable` (*sid/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/d7da72aaf3bb93fecf5fcb7c6ff154cb0c55d1d1/sid/Dockerfile)
-	[`stretch-curl`, `stable-curl`, `curl` (*stretch/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/stretch/curl/Dockerfile)
-	[`stretch-scm`, `stable-scm`, `scm` (*stretch/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/1845b3f918f69b4c97912b0d4d68a5658458e84f/stretch/scm/Dockerfile)
-	[`stretch`, `stable`, `latest` (*stretch/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/d7da72aaf3bb93fecf5fcb7c6ff154cb0c55d1d1/stretch/Dockerfile)
-	[`trusty-curl`, `14.04-curl` (*trusty/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/trusty/curl/Dockerfile)
-	[`trusty-scm`, `14.04-scm` (*trusty/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/1845b3f918f69b4c97912b0d4d68a5658458e84f/trusty/scm/Dockerfile)
-	[`trusty`, `14.04` (*trusty/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/d7da72aaf3bb93fecf5fcb7c6ff154cb0c55d1d1/trusty/Dockerfile)
-	[`wheezy-curl`, `oldoldstable-curl` (*wheezy/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/wheezy/curl/Dockerfile)
-	[`wheezy-scm`, `oldoldstable-scm` (*wheezy/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/1845b3f918f69b4c97912b0d4d68a5658458e84f/wheezy/scm/Dockerfile)
-	[`wheezy`, `oldoldstable` (*wheezy/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/d7da72aaf3bb93fecf5fcb7c6ff154cb0c55d1d1/wheezy/Dockerfile)
-	[`xenial-curl`, `16.04-curl` (*xenial/curl/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/b0fc01aa5e3aed6820d8fed6f3301e0542fbeb36/xenial/curl/Dockerfile)
-	[`xenial-scm`, `16.04-scm` (*xenial/scm/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/2da658b9a1b91fa61d63ffad2ea52685cac6c702/xenial/scm/Dockerfile)
-	[`xenial`, `16.04` (*xenial/Dockerfile*)](https://github.com/docker-library/buildpack-deps/blob/d7da72aaf3bb93fecf5fcb7c6ff154cb0c55d1d1/xenial/Dockerfile)

# Quick reference

-	**Where to get help**:
	[the Docker Community Forums](https://forums.docker.com/), [the Docker Community Slack](https://blog.docker.com/2016/11/introducing-docker-community-directory-docker-community-slack/), or [Stack Overflow](https://stackoverflow.com/search?tab=newest&q=docker)

-	**Where to file issues**:
	[https://github.com/docker-library/buildpack-deps/issues](https://github.com/docker-library/buildpack-deps/issues)

-	**Maintained by**:
	[the Docker Community](https://github.com/docker-library/buildpack-deps)

-	**Supported architectures**: ([more info](https://github.com/docker-library/official-images#architectures-other-than-amd64))
	[`amd64`](https://hub.docker.com/r/amd64/buildpack-deps/), [`arm32v5`](https://hub.docker.com/r/arm32v5/buildpack-deps/), [`arm32v7`](https://hub.docker.com/r/arm32v7/buildpack-deps/), [`arm64v8`](https://hub.docker.com/r/arm64v8/buildpack-deps/), [`i386`](https://hub.docker.com/r/i386/buildpack-deps/), [`ppc64le`](https://hub.docker.com/r/ppc64le/buildpack-deps/), [`s390x`](https://hub.docker.com/r/s390x/buildpack-deps/)

-	**Published image artifact details**:
	[repo-info repo's `repos/buildpack-deps/` directory](https://github.com/docker-library/repo-info/blob/master/repos/buildpack-deps) ([history](https://github.com/docker-library/repo-info/commits/master/repos/buildpack-deps))
	(image metadata, transfer size, etc)

-	**Image updates**:
	[official-images PRs with label `library/buildpack-deps`](https://github.com/docker-library/official-images/pulls?q=label%3Alibrary%2Fbuildpack-deps)
	[official-images repo's `library/buildpack-deps` file](https://github.com/docker-library/official-images/blob/master/library/buildpack-deps) ([history](https://github.com/docker-library/official-images/commits/master/library/buildpack-deps))

-	**Source of this description**:
	[docs repo's `buildpack-deps/` directory](https://github.com/docker-library/docs/tree/master/buildpack-deps) ([history](https://github.com/docker-library/docs/commits/master/buildpack-deps))

-	**Supported Docker versions**:
	[the latest release](https://github.com/docker/docker-ce/releases/latest) (down to 1.6 on a best-effort basis)

# What is `buildpack-deps`?

In spirit, `buildpack-deps` is similar to [Heroku's stack images](https://github.com/heroku/stack-images/blob/master/bin/cedar.sh). It includes a large number of "development header" packages needed by various things like Ruby Gems, PyPI modules, etc. For example, `buildpack-deps` would let you do a `bundle install` in an arbitrary application directory without knowing beforehand that `ssl.h` is required to build a dependent module.

![logo](https://raw.githubusercontent.com/docker-library/docs/01c12653951b2fe592c1f93a13b4e289ada0e3a1/buildpack-deps/logo.png)

# How to use this image

This stack is designed to be the foundation of a language-stack image.

## What's included?

The main tags of this image are the full batteries-included approach. With them, a majority of arbitrary `gem install` / `npm install` / `pip install` should be successful without additional header/development packages.

For some language stacks, that doesn't make sense, particularly if linking to arbitrary external C libraries is much less common (as in Go and Java, for example), which is where these other smaller variants can come in handy.

### `curl`

This variant includes just the `curl`, `wget`, and `ca-certificates` packages. This is perfect for cases like the Java JRE, where downloading JARs is very common and necessary, but checking out code isn't.

### `scm`

This variant is based on `curl`, but also adds various source control management tools. As of this writing, the current list of included tools is `bzr`, `git`, `hg`, and `svn`. Intentionally missing is `cvs` due to the dwindling relevance it has (sorry CVS). This image is perfect for cases like the Java JDK, where downloading JARs is very common (hence the `curl` base still), but checking out code also becomes more common as well (compared to the JRE).

# License

View [license information](https://www.debian.org/social_contract#guidelines) for the software contained in this image.

As with all Docker images, these likely also contain other software which may be under other licenses (such as Bash, etc from the base distribution, along with any direct or indirect dependencies of the primary software being contained).

Some additional license information which was able to be auto-detected might be found in [the `repo-info` repository's `buildpack-deps/` directory](https://github.com/docker-library/repo-info/tree/master/repos/buildpack-deps).

As for any pre-built image usage, it is the image user's responsibility to ensure that any use of this image complies with any relevant licenses for all software contained within.


text:
package iexec

import (
	"io"
	"os"
	"os/exec"
	"syscall"

	"github.com/BooleanCat/igo/ios"
)

//CmdProvider is a type alias for exec.Command
type CmdProvider func(name string, args ...string) Cmd

//Cmd is an interface around exec.Cmd
type Cmd interface {
	CombinedOutput() ([]byte, error)
	Output() ([]byte, error)
	Run() error
	Start() error
	StderrPipe() (io.ReadCloser, error)
	StdinPipe() (io.WriteCloser, error)
	StdoutPipe() (io.ReadCloser, error)
	Wait() error
	GetPath() string
	SetPath(string)
	GetArgs() []string
	SetArgs([]string)
	GetEnv() []string
	SetEnv([]string)
	GetDir() string
	SetDir(string)
	GetStdin() io.Reader
	SetStdin(io.Reader)
	GetStdout() io.Writer
	SetStdout(io.Writer)
	GetStderr() io.Writer
	SetStderr(io.Writer)
	GetExtraFiles() []*os.File
	SetExtraFiles([]*os.File)
	GetSysProcAttr() *syscall.SysProcAttr
	SetSysProcAttr(*syscall.SysProcAttr)
	GetProcess() ios.Process
	SetProcess(*os.Process)
	GetProcessState() *os.ProcessState
	SetProcessState(*os.ProcessState)
}

//CmdReal is a wrapper around exec.Cmd that implements iexec.Cmd
type CmdReal struct {
	cmd *exec.Cmd
}

//NewCmd creates a struct that behaves like exec.Cmd
func NewCmd(cmd ...*exec.Cmd) *CmdReal {
	if len(cmd) > 0 {
		return &CmdReal{cmd: cmd[0]}
	}
	return &CmdReal{cmd: new(exec.Cmd)}
}

//CombinedOutput is a wrapper around exec.Cmd.CombinedOutput()
func (c *CmdReal) CombinedOutput() ([]byte, error) {
	return c.cmd.CombinedOutput()
}

//Output is a wrapper around exec.Cmd.Output()
func (c *CmdReal) Output() ([]byte, error) {
	return c.cmd.Output()
}

//Run is a wrapper around exec.Cmd.Run()
func (c *CmdReal) Run() error {
	return c.cmd.Run()
}

//Start is a wrapper around exec.Cmd.Start()
func (c *CmdReal) Start() error {
	return c.cmd.Start()
}

//StderrPipe is a wrapper around exec.Cmd.StderrPipe()
func (c *CmdReal) StderrPipe() (io.ReadCloser, error) {
	return c.cmd.StderrPipe()
}

//StdinPipe is a wrapper around exec.Cmd.StdinPipe()
func (c *CmdReal) StdinPipe() (io.WriteCloser, error) {
	return c.cmd.StdinPipe()
}

//StdoutPipe is a wrapper around exec.Cmd.StdoutPipe()
func (c *CmdReal) StdoutPipe() (io.ReadCloser, error) {
	return c.cmd.StdoutPipe()
}

//Wait is a wrapper around exec.Cmd.Wait()
func (c *CmdReal) Wait() error {
	return c.cmd.Wait()
}

//GetPath is a wrapper around getting exec.Cmd.Path
func (c *CmdReal) GetPath() string {
	return c.cmd.Path
}

//SetPath is a wrapper around setting exec.Cmd.Path
func (c *CmdReal) SetPath(path string) {
	c.cmd.Path = path
}

//GetArgs is a wrapper around getting exec.Cmd.Args
func (c *CmdReal) GetArgs() []string {
	return c.cmd.Args
}

//SetArgs is a wrapper around setting exec.Cmd.Args
func (c *CmdReal) SetArgs(args []string) {
	c.cmd.Args = args
}

//GetEnv is a wrapper around getting exec.Cmd.Env
func (c *CmdReal) GetEnv() []string {
	return c.cmd.Env
}

//SetEnv is a wrapper around setting exec.Cmd.Env
func (c *CmdReal) SetEnv(env []string) {
	c.cmd.Env = env
}

//GetDir is a wrapper around getting exec.Cmd.Dir
func (c *CmdReal) GetDir() string {
	return c.cmd.Dir
}

//SetDir is a wrapper around setting exec.Cmd.Dir
func (c *CmdReal) SetDir(dir string) {
	c.cmd.Dir = dir
}

//GetStdin is a wrapper around getting exec.Cmd.Stdin
func (c *CmdReal) GetStdin() io.Reader {
	return c.cmd.Stdin
}

//SetStdin is a wrapper around setting exec.Cmd.Stdin
func (c *CmdReal) SetStdin(stdin io.Reader) {
	c.cmd.Stdin = stdin
}

//GetStdout is a wrapper around getting exec.Cmd.Stdout
func (c *CmdReal) GetStdout() io.Writer {
	return c.cmd.Stdout
}

//SetStdout is a wrapper around setting exec.Cmd.Stdout
func (c *CmdReal) SetStdout(stdout io.Writer) {
	c.cmd.Stdout = stdout
}

//GetStderr is a wrapper around getting exec.Cmd.Stderr
func (c *CmdReal) GetStderr() io.Writer {
	return c.cmd.Stderr
}

//SetStderr is a wrapper around setting exec.Cmd.Stderr
func (c *CmdReal) SetStderr(stderr io.Writer) {
	c.cmd.Stderr = stderr
}

//GetExtraFiles is a wrapper around getting exec.Cmd.ExtraFiles
func (c *CmdReal) GetExtraFiles() []*os.File {
	return c.cmd.ExtraFiles
}

//SetExtraFiles is a wrapper around setting exec.Cmd.ExtraFiles
func (c *CmdReal) SetExtraFiles(files []*os.File) {
	c.cmd.ExtraFiles = files
}

//GetSysProcAttr is a wrapper around getting exec.Cmd.SysProcAttr
func (c *CmdReal) GetSysProcAttr() *syscall.SysProcAttr {
	return c.cmd.SysProcAttr
}

//SetSysProcAttr is a wrapper around setting exec.Cmd.SysProcAttr
func (c *CmdReal) SetSysProcAttr(attr *syscall.SysProcAttr) {
	c.cmd.SysProcAttr = attr
}

//GetProcess is a wrapper around getting exec.Cmd.Process as an ios.Process
func (c *CmdReal) GetProcess() ios.Process {
	return ios.NewProcess(c.cmd.Process)
}

//SetProcess is a wrapper around setting exec.Cmd.Process
func (c *CmdReal) SetProcess(process *os.Process) {
	c.cmd.Process = process
}

//GetProcessState is a wrapper around getting exec.Cmd.ProcessState
func (c *CmdReal) GetProcessState() *os.ProcessState {
	return c.cmd.ProcessState
}

//SetProcessState is a wrapper around setting exec.Cmd.ProcessState
func (c *CmdReal) SetProcessState(state *os.ProcessState) {
	c.cmd.ProcessState = state
}


text:
namespace app {
namespace Outracks {
namespace Simulator {
namespace Runtime {

struct UxProperty__Fuse_Elements_TextWrapping;

struct UxProperty__Fuse_Elements_TextWrapping__uType : ::app::Uno::UX::Property__Fuse_Elements_TextWrapping__uType
{
};

UxProperty__Fuse_Elements_TextWrapping__uType* UxProperty__Fuse_Elements_TextWrapping__typeof();

void UxProperty__Fuse_Elements_TextWrapping___ObjInit_1(UxProperty__Fuse_Elements_TextWrapping* __this, ::uDelegate* setter, ::uDelegate* getter, ::uDelegate* adder, ::uDelegate* remover);
UxProperty__Fuse_Elements_TextWrapping* UxProperty__Fuse_Elements_TextWrapping__New_1(::uStatic* __this, ::uDelegate* setter, ::uDelegate* getter, ::uDelegate* adder, ::uDelegate* remover);
void UxProperty__Fuse_Elements_TextWrapping__OnAddListener(UxProperty__Fuse_Elements_TextWrapping* __this, ::uDelegate* listener);
int UxProperty__Fuse_Elements_TextWrapping__OnGet(UxProperty__Fuse_Elements_TextWrapping* __this);
void UxProperty__Fuse_Elements_TextWrapping__OnRemoveListener(UxProperty__Fuse_Elements_TextWrapping* __this, ::uDelegate* listener);
void UxProperty__Fuse_Elements_TextWrapping__OnSet(UxProperty__Fuse_Elements_TextWrapping* __this, int value, ::uObject* origin);

struct UxProperty__Fuse_Elements_TextWrapping : ::app::Uno::UX::Property__Fuse_Elements_TextWrapping
{
    ::uStrong< ::uDelegate*> _setter;
    ::uStrong< ::uDelegate*> _getter;
    ::uStrong< ::uDelegate*> _adder;
    ::uStrong< ::uDelegate*> _remover;

    void _ObjInit_1(::uDelegate* setter, ::uDelegate* getter, ::uDelegate* adder, ::uDelegate* remover) { UxProperty__Fuse_Elements_TextWrapping___ObjInit_1(this, setter, getter, adder, remover); }
};

}}}}

#endif


text:
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Sicheng Yu | IsaacChanghau</title>
    <link>/authors/sicheng-yu/</link>
      <atom:link href="/authors/sicheng-yu/index.xml" rel="self" type="application/rss+xml" />
    <description>Sicheng Yu</description>
    <generator>Source Themes Academic (https://sourcethemes.com/academic/)</generator><language>en-us</language><copyright>© IsaacChanghau · 2017-2021</copyright><lastBuildDate>Wed, 28 Jul 2021 00:00:00 +0000</lastBuildDate>
    <image>
      <url>/images/icon_hu1b364a951019a703f13d3cf900b79a27_31514_512x512_fill_lanczos_center_3.png</url>
      <title>Sicheng Yu</title>
      <link>/authors/sicheng-yu/</link>
    </image>

    <item>
      <title>COSY: COunterfactual SYntax for Cross-Lingual Understanding</title>
      <link>/publication/cosy/</link>
      <pubDate>Wed, 28 Jul 2021 00:00:00 +0000</pubDate>
      <guid>/publication/cosy/</guid>
      <description></description>
    </item>

  </channel>
</rss>


text:
package util

import (
	"encoding/json"
	"errors"
	"os"

	"github.com/mitchellh/go-homedir"
)

func MarshalJSONFromPathOrContent(pathOrContent string, destination interface{}) error {
	// 今の所JSONのみ対応
	data, err := BytesFromPathOrContent(pathOrContent)
	if err != nil {
		return err
	}
	return json.Unmarshal(data, destination)
}

func StringFromPathOrContent(pathOrContent string) (string, error) {
	data, err := BytesFromPathOrContent(pathOrContent)
	if err != nil {
		return "", err
	}
	return string(data), nil
}

func BytesFromPathOrContent(pathOrContent string) ([]byte, error) {
	if pathOrContent == "" {
		return nil, errors.New("pathOrContent required")
	}

	poc, err := homedir.Expand(pathOrContent)
	if err != nil {
		return nil, errors.New("got invalid pathOrContent")
	}

	data, err := os.ReadFile(poc)
	if err != nil {
		return []byte(poc), nil // ファイルを読んでみてエラーだった場合はJSONなどのコンテンツと判定する
	}
	return data, nil
}


text:
module SensuPluginsLogstash
  module Version
    MAJOR = 2
    MINOR = 1
    PATCH = 0

    VER_STRING = [MAJOR, MINOR, PATCH].compact.join('.')
  end
end


text:
package models.daoapriori

import models.DataRule.SupKon

trait SupKonDAO {
	def minimumSupport: Int
	def save(supKon: SupKon)
	def panjang: Int
	def all: List[SupKon]
	def delete(sup: Int): Int
	def getBundle: Int
}


text:
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/gunnarhafdal/GHNavigationDropdownMenu/blob/master/LICENSE)
![Language](https://img.shields.io/badge/language-Swift-brightgreen.svg?style=flat)

## Introduction:
The elegant dropdown menu, written in **Swift**, appears underneath navigation bar to display a list of related items when a user click on the navigation title. Forked from [PhamBaTho/BTNavigationDropdownMenu](https://github.com/PhamBaTho/BTNavigationDropdownMenu) because I needed Swift3 support and support for a subtitle in the menu items.

## Usage:
### Instantiating
Start by creating an Array that contains strings as **elements of dropdown list**:
```swift
let items = [
            GHDropdownItem(title: "Most Popular", subtitle: "from our users"),
            GHDropdownItem(title: "Latest", subtitle: ""),
            GHDropdownItem(title: "Trending", subtitle: "See what's happening"),
            GHDropdownItem(title: "Nearest", subtitle: "to you"),
            GHDropdownItem(title: "Top Picks", subtitle: "by our editors"),
        ]
```
Create a **new instance** of GHNavigationDropdownMenu:
```swift
let menuView = GHNavigationDropdownMenu(navigationController: self.navigationController, containerView: self.navigationController!.view, title: "Dropdown Menu", items: items)
```
or just simple like this:
```swift
let menuView = GHNavigationDropdownMenu(title: items[0], items: items)
```
By default, `navigationController` is the top most navigation controller and `containerView` is keyWindow.

(`keyWindow` is recommended for `containerView` because in this way, the black overlay can cover the whole screen. But in some cases, `keyWindow` doesn't work properly, like using with side menu, (e.g. SWRevealViewController), the dropdown menu didn't move along with their parent view controller or navigation controller. To resolve this issue, you can use `self.navigationController!.view` instead.)

Set **title of navigation bar** as menuView:
```swift
self.navigationItem.titleView = menuView
```
Call GHNavigationDropdownMenu closure to get **the index of selected cell**:
```swift
menuView.didSelectItemAtIndexHandler = {[weak self] (indexPath: Int) -> () in
            print("Did select item at index: \(indexPath)")
            self.selectedCellLabel.text = items[indexPath]
}
```
Use `menuView.show()` or `menuView.hide()` if you want to show or hide dropdown menu manually.

Use `menuView.toggle()` to toogle dropdown menu shown/hide.

Use `menuView.isShown` (Boolean type) property to check showing state of dropdown menu.

Use `menuView.updateItems(items: [AnyObject])` to update items in dropdown menu if needed.

### Customization
Once you have assigned the items and frame for dropdown menu, you can custom the look and the feel of menu. You can override these properties for your favor:

`cellHeight` **- The height of the cell.** *Default is 50*

`cellBackgroundColor` **- The color of the cell background.** *Default is whiteColor()*

`cellSeparatorColor` **- The color of the cell separator.** *Default is darkGrayColor()*

`cellTextLabelColor` **- The color of the text inside cell.** *Default is darkGrayColor()*

`cellTextLabelFont` **- The font of the text inside cell.** *Default is HelveticaNeue-Bold, size 17*

`navigationBarTitleFont` **- The font of the navigation bar title.** *Default is HelveticaNeue-Bold, size 17*

`cellTextLabelAlignment` **- The alignment of the text inside cell.** *Default is .Left*

`cellSelectionColor`  **- The color of the cell when the cell is selected.** *Default is lightGrayColor()*

`checkMarkImage`  **- The checkmark icon of the cell.**

`animationDuration`  **- The animation duration of showing/hiding menu.** *Default is 0.5s*

`arrowImage`  **- The arrow next to navigation title**

`arrowPadding`  **- The padding between navigation title and arrow.** *Default is 15*

`maskBackgroundColor`  **- The color of the mask layer.** *Default is blackColor()*

`maskBackgroundOpacity`  **- The opacity of the mask layer.** *Default is 0.3*

`shouldKeepSelectedCellColor` **- The boolean value that decides if selected color of cell is visible when the menu is shown.** *Default is false*

`shouldChangeTitleText` **- The boolean value that decides if you want to change the title text when a cell is selected.** *Default is true*

`selectedCellTextLabelColor`  **- The color of the selected cell text label.** *Default is darkGrayColor()*

`arrowTintColor`  **- The tint color of the arrow.** *Default is whiteColor()*

## Requirement
- iOS 9.3+
- Xcode 9.0+, Swift 4.0+

## Changelog
See the [CHANGELOG](https://github.com/gunnarhafdal/GHNavigationDropdownMenu/blob/master/CHANGELOG.md) for details

## License
GHNavigationDropdownMenu is available under the MIT License. See the [LICENSE](https://github.com/gunnarhafdal/GHNavigationDropdownMenu/blob/master/LICENSE) for details.


text:
import { expect } from 'chai';
import 'mocha';

import { Tag } from 'aws-sdk/clients/iam';

import { translateAttributes } from '../../../src/resources/iam/kubernetes-to-aws';
import { Effect } from '../../../src/types/aws';

describe('iam/kubernetes-to-aws.spec', function utilsTest() {
	describe('translateAttributes behavior', () => {
		it('doesn\'t change the operand of conditions', () => {
			const attributes = translateAttributes({
				metadata: {
					name: 'TestRole',
				},
				spec: {
					policies: [
						{
							statement: [
								{
									action: ['ses:SendRawEmail'],
									condition: {
										StringEquals: {
											'ses:FromAddress': 'me@example.com',
										},
									},
									effect: 'Allow' as Effect,
									resource: '*',
								},
							],
						},
					],
				},
			});
			expect(attributes.policies).to.be.deep.equal([
				{
					Statement: [
						{
							Action: ['ses:SendRawEmail'],
							Condition: {
								StringEquals: {
									'ses:FromAddress': 'me@example.com',
								},
							},
							Effect: 'Allow',
							Resource: '*',
						},
					],
				},
			]);
		});

		describe('Tags', () => {
			it('translates tags', () => {
				const expected: Tag[] = [
					{
						Key: 'Environment',
						Value: 'master',
					},
				];
				const {tags} = translateAttributes({
					metadata: {
						name: 'TestRole',
					},
					spec: {
						policies: [],
						tags: [
							{
								key: 'Environment',
								value: 'master',
							},
						],
					},
				});
				expect(tags).to.be.deep.equals(expected);
			});
			it('returns an empty tag list if tags are missing', () => {
				const {tags} = translateAttributes({
					metadata: {
						name: 'TestRole',
					},
					spec: {
						policies: [],
					},
				});
				expect(tags).to.be.deep.equals([]);
			});
		});
	});
});


text:
(function() {

    module("utils");

    // ----------
    test("addRemoveClass", function() {
        var div = OpenSeadragon.makeNeutralElement('div');
        strictEqual(div.className, '',
            "makeNeutralElement set no classes");

        OpenSeadragon.addClass(div, 'foo');
        strictEqual(div.className, 'foo',
            "Added first class");
        OpenSeadragon.addClass(div, 'bar');
        strictEqual(div.className, 'foo bar',
            "Added second class");
        OpenSeadragon.addClass(div, 'baz');
        strictEqual(div.className, 'foo bar baz',
            "Added third class");
        OpenSeadragon.addClass(div, 'plugh');
        strictEqual(div.className, 'foo bar baz plugh',
            "Added fourth class");

        OpenSeadragon.addClass(div, 'foo');
        strictEqual(div.className, 'foo bar baz plugh',
            "Re-added first class");
        OpenSeadragon.addClass(div, 'bar');
        strictEqual(div.className, 'foo bar baz plugh',
            "Re-added middle class");
        OpenSeadragon.addClass(div, 'plugh');
        strictEqual(div.className, 'foo bar baz plugh',
            "Re-added last class");

        OpenSeadragon.removeClass(div, 'xyzzy');
        strictEqual(div.className, 'foo bar baz plugh',
            "Removed nonexistent class");
        OpenSeadragon.removeClass(div, 'ba');
        strictEqual(div.className, 'foo bar baz plugh',
            "Removed nonexistent class with existent substring");

        OpenSeadragon.removeClass(div, 'bar');
        strictEqual(div.className, 'foo baz plugh',
            "Removed middle class");
        OpenSeadragon.removeClass(div, 'plugh');
        strictEqual(div.className, 'foo baz',
            "Removed last class");
        OpenSeadragon.removeClass(div, 'foo');
        strictEqual(div.className, 'baz',
            "Removed first class");
        OpenSeadragon.removeClass(div, 'baz');
        strictEqual(div.className, '',
            "Removed only class");
    });

    // ----------
    asyncTest("makeAjaxRequest", function() {
        var timeWatcher = Util.timeWatcher();

        OpenSeadragon.makeAjaxRequest('data/testpattern.dzi', function(xhr) {
            ok(/deepzoom/.test(xhr.response), 'file loaded');
            timeWatcher.done();
        });
    });

    // ----------
    asyncTest("requestAnimationFrame", function() {
        var timeWatcher = Util.timeWatcher();

        OpenSeadragon.requestAnimationFrame(function() {
            ok(true, 'frame fired');
            timeWatcher.done();
        });
    });

    // ----------
    asyncTest("cancelAnimationFrame", function() {
        var frameFired = false;

        setTimeout(function() {
            strictEqual(frameFired, false, 'the frame never fired');
            start();
        }, 150);

        var frameId = OpenSeadragon.requestAnimationFrame(function() {
            frameFired = true;
        });

        OpenSeadragon.cancelAnimationFrame(frameId);
    });

})();


text:
#ifndef QT3DINPUT_QABSTRACTPHYSICALDEVICEPROXY_P_P_H
#define QT3DINPUT_QABSTRACTPHYSICALDEVICEPROXY_P_P_H

//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists for the convenience
// of other Qt classes.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//

#include <Qt3DInput/private/qabstractphysicaldevice_p.h>
#include <Qt3DInput/private/qabstractphysicaldeviceproxy_p.h>
#include <Qt3DInput/private/qt3dinput_global_p.h>

QT_BEGIN_NAMESPACE

namespace Qt3DInput {

class QAbstractPhysicalDeviceProxy;
class QAbstractPhysicalDevice;

class QT3DINPUTSHARED_PRIVATE_EXPORT QAbstractPhysicalDeviceProxyPrivate : public QAbstractPhysicalDevicePrivate
{
public:
    explicit QAbstractPhysicalDeviceProxyPrivate(const QString &deviceName);
    ~QAbstractPhysicalDeviceProxyPrivate();

    Q_DECLARE_PUBLIC(QAbstractPhysicalDeviceProxy)
    QString m_deviceName;
    QAbstractPhysicalDeviceProxy::DeviceStatus m_status;
    QAbstractPhysicalDevice *m_device;

    void setStatus(QAbstractPhysicalDeviceProxy::DeviceStatus status);
};

struct QAbstractPhysicalDeviceProxyData
{
    QString deviceName;
};

} // Qt3DInput

QT_END_NAMESPACE

#endif // QT3DINPUT_QABSTRACTPHYSICALDEVICEPROXY_P_P_H


text:
package armcosmos

import (
	"context"
	"errors"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/arm"
	armruntime "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm/runtime"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
	"net/url"
	"strings"
)

// RestorableDatabaseAccountsClient contains the methods for the RestorableDatabaseAccounts group.
// Don't use this type directly, use NewRestorableDatabaseAccountsClient() instead.
type RestorableDatabaseAccountsClient struct {
	host           string
	subscriptionID string
	pl             runtime.Pipeline
}

// NewRestorableDatabaseAccountsClient creates a new instance of RestorableDatabaseAccountsClient with the specified values.
// subscriptionID - The ID of the target subscription.
// credential - used to authorize requests. Usually a credential from azidentity.
// options - pass nil to accept the default values.
func NewRestorableDatabaseAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*RestorableDatabaseAccountsClient, error) {
	if options == nil {
		options = &arm.ClientOptions{}
	}
	ep := cloud.AzurePublic.Services[cloud.ResourceManager].Endpoint
	if c, ok := options.Cloud.Services[cloud.ResourceManager]; ok {
		ep = c.Endpoint
	}
	pl, err := armruntime.NewPipeline(moduleName, moduleVersion, credential, runtime.PipelineOptions{}, options)
	if err != nil {
		return nil, err
	}
	client := &RestorableDatabaseAccountsClient{
		subscriptionID: subscriptionID,
		host:           ep,
		pl:             pl,
	}
	return client, nil
}

// GetByLocation - Retrieves the properties of an existing Azure Cosmos DB restorable database account. This call requires
// 'Microsoft.DocumentDB/locations/restorableDatabaseAccounts/read/*' permission.
// If the operation fails it returns an *azcore.ResponseError type.
// Generated from API version 2022-08-15-preview
// location - Cosmos DB region, with spaces between words and each word capitalized.
// instanceID - The instanceId GUID of a restorable database account.
// options - RestorableDatabaseAccountsClientGetByLocationOptions contains the optional parameters for the RestorableDatabaseAccountsClient.GetByLocation
// method.
func (client *RestorableDatabaseAccountsClient) GetByLocation(ctx context.Context, location string, instanceID string, options *RestorableDatabaseAccountsClientGetByLocationOptions) (RestorableDatabaseAccountsClientGetByLocationResponse, error) {
	req, err := client.getByLocationCreateRequest(ctx, location, instanceID, options)
	if err != nil {
		return RestorableDatabaseAccountsClientGetByLocationResponse{}, err
	}
	resp, err := client.pl.Do(req)
	if err != nil {
		return RestorableDatabaseAccountsClientGetByLocationResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return RestorableDatabaseAccountsClientGetByLocationResponse{}, runtime.NewResponseError(resp)
	}
	return client.getByLocationHandleResponse(resp)
}

// getByLocationCreateRequest creates the GetByLocation request.
func (client *RestorableDatabaseAccountsClient) getByLocationCreateRequest(ctx context.Context, location string, instanceID string, options *RestorableDatabaseAccountsClientGetByLocationOptions) (*policy.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/locations/{location}/restorableDatabaseAccounts/{instanceId}"
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	if location == "" {
		return nil, errors.New("parameter location cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{location}", url.PathEscape(location))
	if instanceID == "" {
		return nil, errors.New("parameter instanceID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{instanceId}", url.PathEscape(instanceID))
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.host, urlPath))
	if err != nil {
		return nil, err
	}
	reqQP := req.Raw().URL.Query()
	reqQP.Set("api-version", "2022-08-15-preview")
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header["Accept"] = []string{"application/json"}
	return req, nil
}

// getByLocationHandleResponse handles the GetByLocation response.
func (client *RestorableDatabaseAccountsClient) getByLocationHandleResponse(resp *http.Response) (RestorableDatabaseAccountsClientGetByLocationResponse, error) {
	result := RestorableDatabaseAccountsClientGetByLocationResponse{}
	if err := runtime.UnmarshalAsJSON(resp, &result.RestorableDatabaseAccountGetResult); err != nil {
		return RestorableDatabaseAccountsClientGetByLocationResponse{}, err
	}
	return result, nil
}

// NewListPager - Lists all the restorable Azure Cosmos DB database accounts available under the subscription. This call requires
// 'Microsoft.DocumentDB/locations/restorableDatabaseAccounts/read' permission.
// Generated from API version 2022-08-15-preview
// options - RestorableDatabaseAccountsClientListOptions contains the optional parameters for the RestorableDatabaseAccountsClient.List
// method.
func (client *RestorableDatabaseAccountsClient) NewListPager(options *RestorableDatabaseAccountsClientListOptions) *runtime.Pager[RestorableDatabaseAccountsClientListResponse] {
	return runtime.NewPager(runtime.PagingHandler[RestorableDatabaseAccountsClientListResponse]{
		More: func(page RestorableDatabaseAccountsClientListResponse) bool {
			return false
		},
		Fetcher: func(ctx context.Context, page *RestorableDatabaseAccountsClientListResponse) (RestorableDatabaseAccountsClientListResponse, error) {
			req, err := client.listCreateRequest(ctx, options)
			if err != nil {
				return RestorableDatabaseAccountsClientListResponse{}, err
			}
			resp, err := client.pl.Do(req)
			if err != nil {
				return RestorableDatabaseAccountsClientListResponse{}, err
			}
			if !runtime.HasStatusCode(resp, http.StatusOK) {
				return RestorableDatabaseAccountsClientListResponse{}, runtime.NewResponseError(resp)
			}
			return client.listHandleResponse(resp)
		},
	})
}

// listCreateRequest creates the List request.
func (client *RestorableDatabaseAccountsClient) listCreateRequest(ctx context.Context, options *RestorableDatabaseAccountsClientListOptions) (*policy.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/restorableDatabaseAccounts"
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.host, urlPath))
	if err != nil {
		return nil, err
	}
	reqQP := req.Raw().URL.Query()
	reqQP.Set("api-version", "2022-08-15-preview")
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header["Accept"] = []string{"application/json"}
	return req, nil
}

// listHandleResponse handles the List response.
func (client *RestorableDatabaseAccountsClient) listHandleResponse(resp *http.Response) (RestorableDatabaseAccountsClientListResponse, error) {
	result := RestorableDatabaseAccountsClientListResponse{}
	if err := runtime.UnmarshalAsJSON(resp, &result.RestorableDatabaseAccountsListResult); err != nil {
		return RestorableDatabaseAccountsClientListResponse{}, err
	}
	return result, nil
}

// NewListByLocationPager - Lists all the restorable Azure Cosmos DB database accounts available under the subscription and
// in a region. This call requires 'Microsoft.DocumentDB/locations/restorableDatabaseAccounts/read'
// permission.
// Generated from API version 2022-08-15-preview
// location - Cosmos DB region, with spaces between words and each word capitalized.
// options - RestorableDatabaseAccountsClientListByLocationOptions contains the optional parameters for the RestorableDatabaseAccountsClient.ListByLocation
// method.
func (client *RestorableDatabaseAccountsClient) NewListByLocationPager(location string, options *RestorableDatabaseAccountsClientListByLocationOptions) *runtime.Pager[RestorableDatabaseAccountsClientListByLocationResponse] {
	return runtime.NewPager(runtime.PagingHandler[RestorableDatabaseAccountsClientListByLocationResponse]{
		More: func(page RestorableDatabaseAccountsClientListByLocationResponse) bool {
			return false
		},
		Fetcher: func(ctx context.Context, page *RestorableDatabaseAccountsClientListByLocationResponse) (RestorableDatabaseAccountsClientListByLocationResponse, error) {
			req, err := client.listByLocationCreateRequest(ctx, location, options)
			if err != nil {
				return RestorableDatabaseAccountsClientListByLocationResponse{}, err
			}
			resp, err := client.pl.Do(req)
			if err != nil {
				return RestorableDatabaseAccountsClientListByLocationResponse{}, err
			}
			if !runtime.HasStatusCode(resp, http.StatusOK) {
				return RestorableDatabaseAccountsClientListByLocationResponse{}, runtime.NewResponseError(resp)
			}
			return client.listByLocationHandleResponse(resp)
		},
	})
}

// listByLocationCreateRequest creates the ListByLocation request.
func (client *RestorableDatabaseAccountsClient) listByLocationCreateRequest(ctx context.Context, location string, options *RestorableDatabaseAccountsClientListByLocationOptions) (*policy.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/locations/{location}/restorableDatabaseAccounts"
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	if location == "" {
		return nil, errors.New("parameter location cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{location}", url.PathEscape(location))
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.host, urlPath))
	if err != nil {
		return nil, err
	}
	reqQP := req.Raw().URL.Query()
	reqQP.Set("api-version", "2022-08-15-preview")
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header["Accept"] = []string{"application/json"}
	return req, nil
}

// listByLocationHandleResponse handles the ListByLocation response.
func (client *RestorableDatabaseAccountsClient) listByLocationHandleResponse(resp *http.Response) (RestorableDatabaseAccountsClientListByLocationResponse, error) {
	result := RestorableDatabaseAccountsClientListByLocationResponse{}
	if err := runtime.UnmarshalAsJSON(resp, &result.RestorableDatabaseAccountsListResult); err != nil {
		return RestorableDatabaseAccountsClientListByLocationResponse{}, err
	}
	return result, nil
}


text:
layout: post
title:  "Card sorting - Improve information architecture"
excerpt: |
    Card sorting is a method for designing user-centric information architecture. In this article, I will attempt to describe its use and its benefits when designing a site as well as showing a concrete example.
thumbnail: "/images/card-sorting-thumb.jpg"
date: 2017-08-21 12:00:00 +0200
lang: en
ref: card-sorting
author: Mathieu Fortune
theme: Case study
---

Card sorting is a method for designing user-centric information architecture. In this article, I will attempt to describe its use and its benefits when designing a site as well as showing a concrete example.

### What is information architecture?

Information architecture (IA) is a key component of a website success with its users. It makes content easy to find when a website is complex.
It refers to the website information structure.
Usually, we use a navigation component (sitemaps, menu, breadcrumb, filters) to navigate inside a website. This navigation is used by the user, and therefore if you want to improve it, card sorting is here to help :) .

### What is Card sorting?

This is an efficient and easy-to-set method of asking users to sort, aggregate information individually on a card and then label each group. It allows designer to involve the user in the creation process by sorting, categorizing and naming the structure of the information. Using feedback of users to build one of the keystones of any website makes their experience more intuitive and enjoyable.

{% include lazy-image.html src="/images/card-sorting-result02.jpg" alt="Photo résultats tri de cartes" caption="Photo card sorting results" %}

### How to create a card sorting?

The good news is that this method is cheap, fast and useful.
To create a card sorting workshop, you just have to write on pieces of paper the elements you want to sort by the user.

This may be :

* Sort products into an E-commerce website
* Organize Q-A section
* Define category labels
* Sorting pages in a menu
* Create product filters name

Then we ask users to group and sort the cards according to their mental model and to give a name to each created heap.

There are three possible approaches of doing it. Open sort, closed sort, and inverted sort.

* Open: Users are free to create and name categories and to group cards into them.
* Closed: Users have pre-defined categories and must group the cards into them.
* Inverted: The architecture is already created, the user is asked to find a precise information and we observe how he managed to do it. It could be a way to validate the first two approaches.

Most of the time, the card sorting is done individually, the user is the only decision-maker. The facilitator can ask questions at the end of the sorting during a debriefing in order to understand the logic behind the choices the user took.
It's also possible to do it in group. This method allows several users to discuss on a sorting to help the facilitator better understand how the cards are sorted.

The number of cards required can vary from 30 to 100. You should keep in mind that more cards means more time to sort and more complexity for the user who will have difficulty to remember all cards.

### Card sorting workshop @1001pharmacies

{% include lazy-image.html src="/images/card-sorting-picture01.jpg" alt="Man smilling at participant during event" caption="Me and my setup for the workshop" figClass="col-half--right" %}

During a start-up assembly event at 1001pharmacies.com, I hosted a card sorting workshop by taking advantage of this event to meet with users and get their opinion on the product category architecture within our E-commerce website.

I used the top seller products for this sorting. To simplify the process, several decks were created in order to allow several users to do the workshop at the same time.
Small tips, for a paper version, don't hesitate to make nice looking plastified cards. This makes the manipulation more fun for the participants.
Also asked the participants to think aloud and don't hesitate to ask questions about what they are doing to better interpret their thinking.

This workshop led to interesting exchanges of opinions among participants. This actually help to understand the diversity of users's logic when they navigate throug an unorganized structure.

{% include lazy-image.html src="/images/card-sorting-picture02.jpg" alt="People chatting during event" caption="People performing the workshop" %}

### Processing results

{% include lazy-image.html src="/images/card-sorting-result01.jpg" alt="Post-it on a table, result of workshop" caption="Post-it of user who performed the workshop" %}

Card sorting lends itself very well to quantitative analyzes, it gives a synthetic view of the sorts made by the users.

For the treatment of these results, I performed what is called a classification by category or histogram.

It is a quantitative method of associating the categories created by the participants. For example, on the this sorting, a majority of participants classified the same products under a "Baby" category, we can then create the hypothesis that the users of the site will be first looking for this type of product under the category "Baby" . However, prior work must be done to group the categories together with a name having the same meaning and to choose a generic name, for example "maternity" and "baby".

These results helped the catalog team to better design categories of the new version of the E-commerce website and to avoid internal debates or the influence of [HIPPO](http://www.askahippo.com/){:target="_blank"}.

### Final Thoughts

Card sorting is a must have technique when designing any website IA because it's cheap, fast and reliable. This is a good way to get acquainted with user centric design, information architecture and it's a fun workshop for participants. But, stay vigilant, it's not the solution to all the problems of a website. Improving the IA only resolve some of them. However, this technique coupled with other user-centric design methods makes it a very good tool to work with when starting a new project or when remaking an existing site.

_If you liked this article and you also want to use this method, do not hesitate to contact me to work with you on your project and make it more user friendly_

  Let's work together !


text:
'use strict';

angular.module('housrApp')
  .directive('likeDislikeButtons', function (LikeDislike) {
    return {
      templateUrl: 'app/like-dislike-buttons/like-dislike-buttons.html',
      restrict: 'EA',
      scope: {
        user: '=',
      },
      link: function ($scope, element, attrs) {
        console.log('foo', attrs, $scope.user);

        $scope.dislike = function(user) {
          LikeDislike.save({
            targetId: user._id,
            type: 'dislike'
          });
          $scope.hide(user);
        };
        $scope.like = function(user) {
          LikeDislike.save({
            targetId: user._id,
            type: 'like'
          }, function(data) {
          });

          $scope.hide(user);
        };
        $scope.hide = function(user) {
          element.parents('md-card').animate({
            opacity: 0
          }).slideUp();
        };
      }
    };
  });


text:
class PasswordStore;
class Profile;
class ProfileSyncService;
class WebDataService;

namespace browser_sync {
class AssociatorInterface;
class ChangeProcessor;
class DataTypeEncryptionHandler;
class DataTypeManager;
class DataTypeManagerObserver;
class FailedDataTypesHandler;
class GenericChangeProcessor;
class SharedChangeProcessor;
class SyncBackendHost;
class SyncPrefs;
class DataTypeErrorHandler;
}  // namespace browser_sync

namespace syncer {
class DataTypeDebugInfoListener;
class SyncableService;
}

namespace history {
class HistoryBackend;
}

// Factory class for all profile sync related classes.
class ProfileSyncComponentsFactory {
 public:
  // The various factory methods for the data type model associators
  // and change processors all return this struct.  This is needed
  // because the change processors typically require a type-specific
  // model associator at construction time.
  //
  // Note: This interface is deprecated in favor of the SyncableService API.
  // New datatypes that do not live on the UI thread should directly return a
  // weak pointer to a syncer::SyncableService. All others continue to return
  // SyncComponents. It is safe to assume that the factory methods below are
  // called on the same thread in which the datatype resides.
  //
  // TODO(zea): Have all datatypes using the new API switch to returning
  // SyncableService weak pointers instead of SyncComponents (crbug.com/100114).
  struct SyncComponents {
    browser_sync::AssociatorInterface* model_associator;
    browser_sync::ChangeProcessor* change_processor;
    SyncComponents(browser_sync::AssociatorInterface* ma,
                   browser_sync::ChangeProcessor* cp)
        : model_associator(ma), change_processor(cp) {}
  };

  virtual ~ProfileSyncComponentsFactory() {}

  // Creates and registers enabled datatypes with the provided
  // ProfileSyncService.
  virtual void RegisterDataTypes(ProfileSyncService* pss) = 0;

  // Instantiates a new DataTypeManager with a SyncBackendHost, a list of data
  // type controllers and a DataTypeManagerObserver.  The return pointer is
  // owned by the caller.
  virtual browser_sync::DataTypeManager* CreateDataTypeManager(
      const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
          debug_info_listener,
      const browser_sync::DataTypeController::TypeMap* controllers,
      const browser_sync::DataTypeEncryptionHandler* encryption_handler,
      browser_sync::SyncBackendHost* backend,
      browser_sync::DataTypeManagerObserver* observer,
      browser_sync::FailedDataTypesHandler* failed_data_types_handler) = 0;

  // Creating this in the factory helps us mock it out in testing.
  virtual browser_sync::SyncBackendHost* CreateSyncBackendHost(
      const std::string& name,
      Profile* profile,
      const base::WeakPtr<browser_sync::SyncPrefs>& sync_prefs) = 0;

  // Creating this in the factory helps us mock it out in testing.
  virtual browser_sync::GenericChangeProcessor* CreateGenericChangeProcessor(
      ProfileSyncService* profile_sync_service,
      browser_sync::DataTypeErrorHandler* error_handler,
      const base::WeakPtr<syncer::SyncableService>& local_service,
      const base::WeakPtr<syncer::SyncMergeResult>& merge_result) = 0;

  virtual browser_sync::SharedChangeProcessor*
      CreateSharedChangeProcessor() = 0;

  // Returns a weak pointer to the syncable service specified by |type|.
  // Weak pointer may be unset if service is already destroyed.
  // Note: Should only be called on the same thread on which a datatype resides.
  virtual base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
      syncer::ModelType type) = 0;

  // Legacy datatypes that need to be converted to the SyncableService API.
  virtual SyncComponents CreateBookmarkSyncComponents(
      ProfileSyncService* profile_sync_service,
      browser_sync::DataTypeErrorHandler* error_handler) = 0;
  virtual SyncComponents CreateTypedUrlSyncComponents(
      ProfileSyncService* profile_sync_service,
      history::HistoryBackend* history_backend,
      browser_sync::DataTypeErrorHandler* error_handler) = 0;
  virtual SyncComponents CreateSessionSyncComponents(
      ProfileSyncService* profile_sync_service,
      browser_sync::DataTypeErrorHandler* error_handler) = 0;
};

#endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_COMPONENTS_FACTORY_H__


text:
package net.linkedbuildingdata.ifc.data.schema;

import net.linkedbuildingdata.ifc.data.Cardinality;

public class IfcListTypeInfo extends IfcCollectionTypeInfo {

	private static final long serialVersionUID = 1L;

	private IfcListTypeInfo superTypeInfo;

	public IfcListTypeInfo(IfcSchema schema, String typeName, IfcTypeInfo itemTypeInfo) {
		super(schema, typeName, itemTypeInfo);
	}

	public IfcListTypeInfo(IfcSchema schema, String typeName, String itemTypeInfoName) {
		super(schema, typeName, itemTypeInfoName);
	}

	public static String formatListTypeName(String itemTypeInfoName, Cardinality cardinality) {
		if (cardinality != null) {
			return String.format("%s_List_%s_%s", itemTypeInfoName, cardinality.getMin(),
					cardinality.getMax() == Cardinality.UNBOUNDED ? "UNBOUNDED" : cardinality.getMax());
		} else {
			return String.format("%s_List", itemTypeInfoName);
		}
	}

	@Override
	public boolean isSorted() {
		return true;
	}

	/**
	 * @return the superTypeInfo
	 */
	public IfcListTypeInfo getSuperTypeInfo() {
		return superTypeInfo;
	}

	/**
	 * @param superTypeInfo the superTypeInfo to set
	 */
	public void setSuperTypeInfo(IfcListTypeInfo superTypeInfo) {
		this.superTypeInfo = superTypeInfo;
	}

	@Override
	public boolean isLiteralContainerType() {
		return getItemTypeInfo().isLiteralContainerType();
	}

}


text:
*NOTE: unfortunately installing and managing Gekko is hard. You will need to touch the commandline and install a few developer tools. I am creating an official Gekko service called [Gekko Plus](https://gekkoplus.com/), it will NOT require any installation.*

### Note:
#### Windows does not natively support TA-lib. We are currently working on implementing the Tulip Indicators Library, which will provide similar functionality (see [#708](https://github.com/askmike/gekko/issues/708)).
#### For advanced users only: As a temporary workaround until [#708](https://github.com/askmike/gekko/issues/708) is implemented, TA-lib can be used on Windows through Bash on Windows 10. See "Installing Gekko on Windows with bash on Windows 10"

Here is a youtube video I made that shows exactly how to set up Gekko:

[![screen shot 2017-04-20 at 00 03 45](https://cloud.githubusercontent.com/assets/969743/25205894/e7f4ea64-255c-11e7-891b-28c080a9fbf2.png)](https://www.youtube.com/watch?v=R68IwVujju8)

To get Gekko running on Windows you need to do the following:

- install nodejs
- download Gekko
- install Gekko's dependencies

## Install nodejs

Gekko runs on nodejs so we have to install that first. Head over the [nodejs homepage](http://nodejs.org/) and install the LTS version of nodejs.

## Install Gekko

The easiest way to download Gekko is to go to the [Github repo](https://github.com/askmike/gekko) and click on the 'zip' button at the top. Once you have downloaded the zip file it's the easiest to extract it. When you have done that we can begin with the cool stuff:

### Open up command line

* Start
* Type in 'cmd.exe'
* Press enter

### Install dependencies

(After every command, press enter)

First navigate to Gekko:

    cd Downloads
    cd gekko-stable
    cd gekko-stable

Install Gekko's dependencies:

    npm install --only=production

*NOTE: You may see a vulnerability warning from NPM, if you run npm audit with --force, Gekko will break. See [here](https://github.com/askmike/gekko/issues/2585#issuecomment-428450997).*

Install Gekko Broker's dependencies:

    cd exchange
    npm install --only=production
    cd ..

### Install Tulip Indicators

If you are using Windows you will need to install python and the VC++ 2015 build tool, the easiest way to do this is through node as an administrator:

    npm install windows-build-tools --global --production

Once your build tools are installed, or for other operating systems

    npm install tulind --only=production

### Starting Gekko

    node gekko --ui

Your browser should automatically open with the UI. If it doesn't, manually browse to [http://localhost:3000](http://localhost:3000).

### Stopping Gekko

In the command line hold `ctrl` + `c`.

### Updating Gekko

See the [updating Gekko](./updating_gekko.md) doc.


text:
package com.smit.openfire.plugin;

import java.util.Collection;

import org.jivesoftware.openfire.group.Group;
import org.jivesoftware.openfire.group.GroupAlreadyExistsException;
import org.jivesoftware.openfire.group.GroupManager;
import org.jivesoftware.openfire.user.User;
import org.xmpp.packet.JID;

public class SmitGroupManager {
	private static SmitGroupManager mInstance = null;

	private SmitGroupManager()
	{

	}

	public static SmitGroupManager instance()
	{
		if(mInstance == null)
		{
			mInstance = new SmitGroupManager();
		}
		return mInstance;
	}

	public Group createGroup(String name)
	{
		Group group = null;
		try {
			group = GroupManager.getInstance().createGroup(name);
			return group;
		} catch (GroupAlreadyExistsException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if(group != null)
		{

		}
		return null;
	}

	public Collection<Group> getAllGroups()
	{
		Collection<Group> groups = GroupManager.getInstance().getGroups();
		return groups;
	}

	public void addMemberToGroup(String groupName, JID user, boolean isAdmin)
	{
		GroupManager.getInstance().getProvider().addMember(groupName, user, isAdmin);
	}

	public Collection<Group> userBelongToWhich(JID user)
	{
		User realuser = new User();
		Collection<Group> groups = GroupManager.getInstance().getGroups(user);
		return groups;
	}
}


text:
ACCEPTED

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

#### Published in
Mycol. Pap. 128: 83 (1972)

#### Original name
Redbia pucciniicola Deighton & Piroz., 1972

### Remarks
null


text:
package ru.job4j;

/**
 * Класс выводит в консоль строку Hello world!
 * @author Valeriy Gubskiy
 * @since 23.06.2017
 * @version 1.0
 */

class Calculate {
	/**.
	* Метод main является точкой входа для выполнения программы
	* @param args в качестве аргументов принимает массив строк
	*/
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}


text:
FROM ubuntu:18.04
ENV PYTHONUNBUFFERED 1
ENV DEBIAN_FRONTEND noninteractive
EXPOSE 8000

# Usual update / upgrade with locale setup
RUN apt-get update \
    && apt-get dist-upgrade -y \
    && apt-get install -yq software-properties-common sudo curl locales\
    && apt-get autoremove -y \
    && rm -rf /var/lib/apt/lists/* \
    && echo en_US.UTF-8 UTF-8 >> /etc/locale.gen \
    && locale-gen \
    && ln -fs /usr/share/zoneinfo/Europe/Helsinki /etc/localtime

ENV LANG='en_US.UTF-8' LANGUAGE='en_US:en' LC_ALL='en_US.UTF-8' LC_CTYPE='en_US.UTF-8'

# Install basics
RUN apt-get update \
    && apt-get install -yq postgresql git python3-dev virtualenv python3-virtualenv vim \
    python3-pip python-pip npm \
    && apt-get autoremove -y \
    && rm -rf /var/lib/apt/lists/*

# Install maildump
EXPOSE 1080
RUN pip install --no-cache-dir maildump

# Create database
USER postgres
RUN service postgresql start && \
    createuser asylum && \
    createdb -E utf-8 -T template0 -O asylum asylum && \
    psql -U postgres -d postgres -c "alter user asylum with password 'asylum'; alter user asylum with createdb;"

# Create a newuser
USER root
RUN adduser --disabled-password --gecos '' asylum && \
    adduser asylum sudo && \
    echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers

# Create volume
RUN mkdir /opt/asylum/ && chown asylum:asylum /opt/asylum/
# VOLUME /opt/asylum/ # Your local uid != 1000? Tough. Create an issue and add an idea how to fix it.
WORKDIR /opt/asylum/

# Install system packages
COPY project/requirements.apt /opt/asylum/
RUN apt-get update \
    && awk '/^\s*[^#]/' requirements.apt | xargs -r -- sudo apt-get install --no-install-recommends -y \
    && apt-get autoremove -y \
    && rm -rf /var/lib/apt/lists/*

USER root

# Install python requirements
RUN virtualenv -p `which python3` ../asylum-venv
COPY project/requirements /opt/asylum/requirements/
RUN . ../asylum-venv/bin/activate && \
    pip3 install --no-cache-dir packaging appdirs urllib3[secure] && \
    pip3 install --no-cache-dir -r requirements/local.txt && \
    chown -R asylum:asylum ../asylum-venv && \
    true

# Configure application
USER root
RUN echo "DATABASE_URL=postgres://asylum:asylum@localhost/asylum" > .env
COPY project /opt/asylum/
RUN chown -R asylum:asylum /opt/asylum/

# Build localisations
USER asylum
RUN . ../asylum-venv/bin/activate && \
    for app in $(find . -name 'locale' -type d); do (cd $app/.. && ../manage.py compilemessages ); done

# Run migrate and create admin user
USER asylum
RUN npm run build \
    && sudo -u postgres service postgresql start; \
    . ../asylum-venv/bin/activate \
    && export PGPASSWORD=asylum; while true; do psql -q asylum -c 'SELECT 1;' 1>/dev/null 2>&1 ; if [ "$?" -ne "0" ]; then echo "Waiting for psql"; sleep 1; else break; fi; done \
    && ./manage.py migrate \
    && echo "from django.contrib.auth.models import User; User.objects.create_superuser('admin', 'nospamplz@hacklab.fi', 'admin') ; from rest_framework.authtoken.models import Token ; Token.objects.create(user=User.objects.get(username='admin'), key='deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')" | ./manage.py shell

ENTRYPOINT ["/opt/asylum/docker-entrypoint.sh"]


text:
"""Adds config flow for Tibber integration."""
import asyncio
import logging

import aiohttp
import tibber
import voluptuous as vol

from homeassistant import config_entries
from homeassistant.const import CONF_ACCESS_TOKEN
from homeassistant.helpers.aiohttp_client import async_get_clientsession

from .const import DOMAIN  # pylint:disable=unused-import

_LOGGER = logging.getLogger(__name__)

DATA_SCHEMA = vol.Schema({vol.Required(CONF_ACCESS_TOKEN): str})

class TibberConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
    """Handle a config flow for Tibber integration."""

    VERSION = 1
    CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL

    async def async_step_import(self, import_info):
        """Set the config entry up from yaml."""
        return await self.async_step_user(import_info)

    async def async_step_user(self, user_input=None):
        """Handle the initial step."""

        if self._async_current_entries():
            return self.async_abort(reason="already_configured")

        if user_input is not None:
            access_token = user_input[CONF_ACCESS_TOKEN].replace(" ", "")

            tibber_connection = tibber.Tibber(
                access_token=access_token,
                websession=async_get_clientsession(self.hass),
            )

            errors = {}

            try:
                await tibber_connection.update_info()
            except asyncio.TimeoutError:
                errors[CONF_ACCESS_TOKEN] = "timeout"
            except aiohttp.ClientError:
                errors[CONF_ACCESS_TOKEN] = "connection_error"
            except tibber.InvalidLogin:
                errors[CONF_ACCESS_TOKEN] = "invalid_access_token"

            if errors:
                return self.async_show_form(
                    step_id="user", data_schema=DATA_SCHEMA, errors=errors,
                )

            unique_id = tibber_connection.user_id
            await self.async_set_unique_id(unique_id)
            self._abort_if_unique_id_configured()

            return self.async_create_entry(
                title=tibber_connection.name, data={CONF_ACCESS_TOKEN: access_token},
            )

        return self.async_show_form(step_id="user", data_schema=DATA_SCHEMA, errors={},)


text:
package li.strolch.runtime.query.enums;

import static org.junit.Assert.assertEquals;

import java.util.Locale;

import li.strolch.RuntimeMock;
import li.strolch.agent.ComponentContainerTest;
import li.strolch.agent.api.ComponentContainer;
import li.strolch.privilege.model.Certificate;
import org.junit.Test;

/**
 * @author Robert von Burg <eitch@eitchnet.ch>
 */
@SuppressWarnings("nls")
public class EnumHandlerTest {

	private static final String ENUM_HANDLER_TEST_RUNTIME = "target/EnumHandlerTest/";

	@Test
	public void shouldFindByLocator() throws Exception {

		RuntimeMock.runInStrolch(ENUM_HANDLER_TEST_RUNTIME, ComponentContainerTest.PATH_TRANSIENT_CONTAINER, agent -> {

			ComponentContainer container = agent.getContainer();

			Certificate certificate = container.getPrivilegeHandler().authenticate("test", "test".toCharArray());

			EnumHandler enumHandler = container.getComponent(EnumHandler.class);
			StrolchEnum sexEnum = enumHandler.getEnum(certificate, "sex", Locale.ENGLISH);
			assertEquals("sex", sexEnum.getName());
			assertEquals("en", sexEnum.getLocale());
			assertEquals(3, sexEnum.size());
			assertEquals("both", sexEnum.getValue("both"));

			StrolchEnum salutationsEnum = enumHandler.getEnum(certificate, "salutations", Locale.UK);
			assertEquals("salutations", salutationsEnum.getName());
			assertEquals("en-GB", salutationsEnum.getLocale());
			assertEquals(3, salutationsEnum.size());
			assertEquals("Mr", salutationsEnum.getValue("mr"));

			StrolchEnum religionsEnum = enumHandler.getEnum(certificate, "religions", Locale.CANADA);
			assertEquals("religions", religionsEnum.getName());
			assertEquals("en-CA", religionsEnum.getLocale());
			assertEquals(9, religionsEnum.size());
			assertEquals("Atheist", religionsEnum.getValue("Atheist"));
		});
	}
}