text:
cabal build
cp dist/build/boustro/boustro.jsexe/all.js ../static/all.js

redpajama_set_name: RedPajamaGithub


text:
using System.Collections.ObjectModel;

namespace DevelopmentInProgress.DipCore.Test
{
    public class TestObjectBase
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    public class Activity : TestObjectBase
    {
        public Activity()
        {
            Activities= new Collection<Activity>();
        }

        public Collection<Activity> Activities { get; set; }
    }

    public class Role : TestObjectBase
    {
        public Role()
        {
            Activities = new Collection<Activity>();
            Roles = new Collection<Role>();
        }

        public Collection<Activity> Activities { get; set; }
        public Collection<Role> Roles { get; set; }
    }

    public class User : TestObjectBase
    {
        public User()
        {
            Roles = new Collection<Role>();
        }

        public Collection<Role> Roles { get; set; }
    }
}


text:
struct EngineSetup
{
	HINSTANCE instance; // Application instance handle.
	GUID guid; // Application GUID.
	char *name; // Name of the application.
	float scale; // Unit scale in meters/unit.
	unsigned char totalBackBuffers; // Number of back buffers to use.
	void (*HandleNetworkMessage)( ReceivedMessage *msg ); // Network message handler.
	void (*StateSetup)(); // State setup function.
	void (*CreateMaterialResource)( Material **resource, char *name, char *path ); // Material resource creation function.

	//-------------------------------------------------------------------------
	// The engine setup structure constructor.
	//-------------------------------------------------------------------------
	EngineSetup()
	{
		GUID defaultGUID = { 0x24215591, 0x24c0, 0x4316, { 0xb5, 0xb2, 0x67, 0x98, 0x2c, 0xb3, 0x82, 0x54 } };

		instance = NULL;
		guid = defaultGUID;
		name = "Application";
		scale = 1.0f;
		totalBackBuffers = 1;
		HandleNetworkMessage = NULL;
		StateSetup = NULL;
		CreateMaterialResource = NULL;
	}
};

//-----------------------------------------------------------------------------
// Engine Class
//-----------------------------------------------------------------------------
class Engine
{
public:
	Engine( EngineSetup *setup = NULL );
	virtual ~Engine();

	void Run();

	HWND GetWindow();
	void SetDeactiveFlag( bool deactive );

	float GetScale();
	IDirect3DDevice9 *GetDevice();
	D3DDISPLAYMODE *GetDisplayMode();
	ID3DXSprite *GetSprite();

	void AddState( State *state, bool change = true );
	void RemoveState( State *state );
	void ChangeState( unsigned long id );
	State *GetCurrentState();

	ResourceManager< Script > *GetScriptManager();
	ResourceManager< Material > *GetMaterialManager();
	ResourceManager< Mesh > *GetMeshManager();

	Input *GetInput();
	Network *GetNetwork();
	SoundSystem *GetSoundSystem();

private:
	bool m_loaded; // Indicates if the engine is loading.
	HWND m_window; // Main window handle.
	bool m_deactive; // Indicates if the application is active or not.

	EngineSetup *m_setup; // Copy of the engine setup structure.
	IDirect3DDevice9 *m_device; // Direct3D device interface.
	D3DDISPLAYMODE m_displayMode; // Display mode of the current Direct3D device.
	ID3DXSprite *m_sprite; // Sprite interface for rendering 2D textured primitives.
	unsigned char m_currentBackBuffer; // Keeps track of which back buffer is at the front of the swap chain.

	LinkedList< State > *m_states; // Linked list of states.
	State *m_currentState; // Pointer to the current state.
	bool m_stateChanged; // Indicates if the state changed in the current frame.

	ResourceManager< Script > *m_scriptManager; // Script manager.
	ResourceManager< Material > *m_materialManager; // Material manager.
	ResourceManager< Mesh > *m_meshManager; // Mesh manager.

	Input *m_input; // Input object.
	Network *m_network; // Network object.
	SoundSystem *m_soundSystem; // Sound system.
};

//-----------------------------------------------------------------------------
// Externals
//-----------------------------------------------------------------------------
extern Engine *g_engine;

#endif


text:
<?php

namespace DvsaCommonTest\Time;

use DvsaCommon\Date\Time;
use PHPUnit\Framework\TestCase;

class TimeUConversionTest extends \PHPUnit\Framework\TestCase
{
    public function testTimestampToTime_givenTimeInSeconds_shouldReturnTime()
    {
        $time = Time::fromTimestamp(0);
        $this->assertEquals( "00:00:00", $time->toIso8601());

        $time = Time::fromTimestamp(00);
        $this->assertEquals("00:00:00", $time->toIso8601());

        $time = Time::fromTimestamp(000);
        $this->assertEquals("00:00:00", $time->toIso8601());

        $time = Time::fromTimestamp(0000);
        $this->assertEquals("00:00:00", $time->toIso8601());

        $time = Time::fromTimestamp(32400);
        $this->assertEquals("09:00:00", $time->toIso8601());

        $time = Time::fromTimestamp(34200);
        $this->assertEquals("09:30:00", $time->toIso8601());

        $time = Time::fromTimestamp(45000);
        $this->assertEquals("12:30:00", $time->toIso8601());

        $time = Time::fromTimestamp(43200);
        $this->assertEquals("12:00:00", $time->toIso8601());
    }

    public function testTimeToInt_givenIsoTime_shouldReturnIntTimeInSeconds()
    {
        $time = Time::fromIso8601("09:00:00");
        $this->assertEquals("32400", $time->toTimestamp());

        $time = Time::fromIso8601("09:30:00");
        $this->assertEquals("34200", $time->toTimestamp());

        $time = Time::fromIso8601("12:30:00");
        $this->assertEquals("45000", $time->toTimestamp());

        $time = Time::fromIso8601("12:00:00");
        $this->assertEquals("43200", $time->toTimestamp());

        $time = Time::fromIso8601("00:00:00");
        $this->assertEquals("0", $time->toTimestamp());
    }

    /**
     * @expectedException        \InvalidArgumentException
     * @expectedExceptionMessage Cannot create time from timestamp: '12:00:00'
     */
    public function testFromTimestamp_givenInvalidTimestamp_shouldThrowException()
    {
        Time::fromTimestamp("12:00:00");
    }

    /**
     * @expectedException        \InvalidArgumentException
     * @expectedExceptionMessage Cannot create time from timestamp: '86400'
     */
    public function testFromTimestamp_givenOutOfBoundsTimestamp_shouldThrowException()
    {
        Time::fromTimestamp(86400);
    }

    /**
     * @expectedException        \InvalidArgumentException
     * @expectedExceptionMessage Cannot create time from timestamp: '-1'
     */
    public function testFromTimestamp_givenNegative_shouldThrowException()
    {
        Time::fromTimestamp(-1);
    }

    /**
     * @expectedException        \InvalidArgumentException
     * @expectedExceptionMessage Cannot create time from timestamp: 'apple'
     */
    public function testFromTimestamp_givenCharacters_shouldThrowException()
    {
        Time::fromTimestamp("apple");
    }

    /**
     * @expectedException        \InvalidArgumentException
     * @expectedExceptionMessage Invalid value " 00 " provided. Provide 00:00:00 format.
     */
    public function testFromIso_givenInvalidTime_shouldThrowException()
    {
        Time::fromIso8601("00");
    }

    /**
     * @expectedException        \InvalidArgumentException
     * @expectedExceptionMessage Invalid value " 24:00:00 " provided. Provide 00:00:00 format.
     */
    public function testFromIso_givenOutOfBoundsHour_shouldThrowException()
    {
        Time::fromIso8601("24:00:00");
    }

    /**
     * @expectedException        \InvalidArgumentException
     * @expectedExceptionMessage Invalid value " 15:60:00 " provided. Provide 00:00:00 format.
     */
    public function testFromIso_givenOutOfBoundsMins_shouldThrowException()
    {
        Time::fromIso8601("15:60:00");
    }

}


text:
package de.fuberlin.wiwiss.d2rq.engine;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import com.hp.hpl.jena.graph.Triple;
import com.hp.hpl.jena.sparql.core.Var;

import de.fuberlin.wiwiss.d2rq.algebra.AliasMap;
import de.fuberlin.wiwiss.d2rq.algebra.AliasMap.Alias;
import de.fuberlin.wiwiss.d2rq.algebra.Attribute;
import de.fuberlin.wiwiss.d2rq.algebra.Join;
import de.fuberlin.wiwiss.d2rq.algebra.VariableConstraints;
import de.fuberlin.wiwiss.d2rq.algebra.NodeRelation;
import de.fuberlin.wiwiss.d2rq.algebra.OrderSpec;
import de.fuberlin.wiwiss.d2rq.algebra.ProjectionSpec;
import de.fuberlin.wiwiss.d2rq.algebra.Relation;
import de.fuberlin.wiwiss.d2rq.algebra.RelationImpl;
import de.fuberlin.wiwiss.d2rq.algebra.RelationName;
import de.fuberlin.wiwiss.d2rq.algebra.TripleRelation;
import de.fuberlin.wiwiss.d2rq.expr.Conjunction;
import de.fuberlin.wiwiss.d2rq.expr.Expression;
import de.fuberlin.wiwiss.d2rq.nodes.NodeMaker;
import de.fuberlin.wiwiss.d2rq.sql.ConnectedDB;

class TripleRelationJoiner {

	public static TripleRelationJoiner create(boolean allOptimizations) {
		return new TripleRelationJoiner(new VariableConstraints(),
				Collections.<Triple>emptyList(), Collections.<NodeRelation>emptyList(),
				allOptimizations);
	}

	private final VariableConstraints nodeSets;
	private final List<Triple> joinedTriplePatterns;
	private final List<NodeRelation> joinedTripleRelations;
	private final boolean useAllOptimizations;

	private TripleRelationJoiner(VariableConstraints nodeSets,
			List<Triple> patterns, List<NodeRelation> relations, boolean useAllOptimizations) {
		this.nodeSets = nodeSets;
		this.joinedTriplePatterns = patterns;
		this.joinedTripleRelations = relations;
		this.useAllOptimizations = useAllOptimizations;
	}

	public List<TripleRelationJoiner> joinAll(Triple pattern,
			List<NodeRelation> candidates) {
		List<TripleRelationJoiner> results = new ArrayList<TripleRelationJoiner>();
		for (NodeRelation tripleRelation: candidates) {
			TripleRelationJoiner nextJoiner = join(pattern, tripleRelation);
			if (nextJoiner != null) {
				results.add(nextJoiner);
			}
		}
		return results;
	}

	private static boolean isUnique(ConnectedDB database, RelationName originalName,
			Set<String> attributeNames)
	{
		Map<String,List<String>> uniqueKeys = database.getUniqueKeyColumns(originalName);
		if (uniqueKeys == null) return false;
		for (List<String> indexColumns: uniqueKeys.values()) {
			if (attributeNames.containsAll(indexColumns)) return true;
		}
		return false;
	}

	private static class AttributeSet {
		RelationName relationName = null;
		Set<String> attributeNames = new TreeSet<String>();

		/*
		 * Determine the attributes that make up a nodemakers projection spec
		 * all must stem from the same table
		 */
		static AttributeSet createFrom(NodeMaker nodeMaker)
		{
			AttributeSet attributes = new AttributeSet();
			Set<ProjectionSpec> projectionSpecs = nodeMaker.projectionSpecs();
			boolean err = projectionSpecs.isEmpty();

			Iterator<ProjectionSpec> projectionIterator = projectionSpecs.iterator();
			while (projectionIterator.hasNext() && !err) {
				ProjectionSpec projection = (ProjectionSpec) projectionIterator.next();

				Set<Attribute> reqAttr = projection.requiredAttributes();
				Iterator<Attribute> j = reqAttr.iterator();
				while (j.hasNext() && !err) {
					Attribute a = (Attribute) j.next();
					if (attributes.relationName == null)
						attributes.relationName = a.relationName();
					else if (!attributes.relationName.equals(a.relationName()))
						err = true;

					attributes.attributeNames.add(a.attributeName());
				}

//				if (projection instanceof Attribute) {
//					Attribute a = (Attribute) projection;
//					if (attributes.relationName == null)
//						attributes.relationName = a.relationName();
//					else if (!attributes.relationName.equals(a.relationName()))
//						err = true;
//
//					attributes.attributeNames.add(a.attributeName());
//				} else {
//					err = true;
//				}
			}

			if (!err)
				return attributes;

			return null;
		}
	}

	private List<RelationName> getRelationNames(NodeMaker nodeMaker)
	{
		List<RelationName> result = new ArrayList<RelationName>();
		Set<ProjectionSpec> projectionSpecs = nodeMaker.projectionSpecs();
		for (ProjectionSpec spec: projectionSpecs) {
			for (Attribute a: spec.requiredAttributes()) {
				result.add(a.relationName());
			}
		}
		return result;
	}

	public TripleRelationJoiner join(Triple pattern, NodeRelation relation) {
		List<Triple> newPatterns = new ArrayList<Triple>(joinedTriplePatterns);
		newPatterns.add(pattern);
		List<NodeRelation> newRelations = new ArrayList<NodeRelation>(joinedTripleRelations);
		newRelations.add(relation);

		VariableConstraints nodeSets = new VariableConstraints();
		for (int i = 0; i < newPatterns.size(); i++) {
			Triple t = (Triple) newPatterns.get(i);
			NodeRelation r = newRelations.get(i);

			if (useAllOptimizations) {
				/*
				 * Before adding a NodeMaker, try to adopt aliases from existing NodeMakers
				 * in order to prevent unnecessary self-joins (#2798308)
				 */
				// This failed when originalName had more than 1 alias r.baseRelation (fixed, GM)
				List<String> names = new ArrayList<String>();

				if (t.getSubject().isVariable())
					names.add(t.getSubject().getName());
				if (t.getPredicate().isVariable())
					names.add(t.getPredicate().getName());
				if (t.getObject().isVariable())
					names.add(t.getObject().getName());

				for (String name: names) {
					NodeMaker n = (NodeMaker) nodeSets.toMap().get(name);
					if (n != null/* && n instanceof TypedNodeMaker*/) {

						AttributeSet attributes = AttributeSet.createFrom(n);
						/*
						 * If we would set an alias to this table...
						 */
						if (attributes != null) {
							RelationName originalName = ((AliasMap)nodeSets.relationAliases().get(name)).originalOf(attributes.relationName);
							if (r.baseRelation().aliases().hasAlias(originalName)) {

								/*
								 * ... and indexes are in place to guarantee uniqueness of the attribute combination...
								 */
								if (isUnique(r.baseRelation().database(), originalName, attributes.attributeNames)) {

									if (t.getSubject().isVariable() && t.getSubject().getName().equals(name)) {
										// ... then first find the right relation name...
										AttributeSet existing = AttributeSet.createFrom(r.nodeMaker(TripleRelation.SUBJECT));
										if (existing != null && existing.attributeNames.equals(attributes.attributeNames)) {
											// ... then apply it
											r = r.renameSingleRelation(existing.relationName, attributes.relationName);
											newRelations.set(i, r);
										}
									}

									if (t.getPredicate().isVariable() && t.getPredicate().getName().equals(name)) {
										// ... then first find the right relation name...
										AttributeSet existing = AttributeSet.createFrom(r.nodeMaker(TripleRelation.PREDICATE));
										if (existing != null && existing.attributeNames.equals(attributes.attributeNames)) {
											// ... then apply it
											r = r.renameSingleRelation(existing.relationName, attributes.relationName);
											newRelations.set(i, r);
										}
									}

									if (t.getObject().isVariable() && t.getObject().getName().equals(name)) {
										// ... then first find the right relation name...
										AttributeSet existing = AttributeSet.createFrom(r.nodeMaker(TripleRelation.OBJECT));
										if (existing != null && existing.attributeNames.equals(attributes.attributeNames)) {
											// ... then apply it
											r = r.renameSingleRelation(existing.relationName, attributes.relationName);
											newRelations.set(i, r);
										}
									}
								}
							}
						}
					}
				}
			}

			if (t.getObject().isVariable()) {
				List<RelationName> relationNames = getRelationNames(
						r.nodeMaker(TripleRelation.OBJECT));
				Set<Alias> aliases = new HashSet<Alias>();

				for (RelationName rname: relationNames) {
					if (r.baseRelation().aliases().isAlias(rname))
						aliases.add(new AliasMap.Alias(r.baseRelation().aliases().originalOf(rname), rname));
				}
				nodeSets.add(Var.alloc(t.getObject()), r.nodeMaker(TripleRelation.OBJECT), new AliasMap(aliases));
			}

			if (t.getPredicate().isVariable()) {
				List<RelationName> relationNames = getRelationNames(
						r.nodeMaker(TripleRelation.PREDICATE));
				Set<Alias> aliases = new HashSet<Alias>();

				for (RelationName rname: relationNames) {
					if (r.baseRelation().aliases().isAlias(rname))
						aliases.add(new AliasMap.Alias(r.baseRelation().aliases().originalOf(rname), rname));
				}
				nodeSets.add(Var.alloc(t.getPredicate()), r.nodeMaker(TripleRelation.PREDICATE), new AliasMap(aliases));
			}

			if (t.getSubject().isVariable()) {
				List<RelationName> relationNames = getRelationNames(
						r.nodeMaker(TripleRelation.SUBJECT));
				Set<Alias> aliases = new HashSet<Alias>();

				for (RelationName rname: relationNames) {
					if (r.baseRelation().aliases().isAlias(rname))
						aliases.add(new AliasMap.Alias(r.baseRelation().aliases().originalOf(rname), rname));
				}
				nodeSets.add(Var.alloc(t.getSubject()), r.nodeMaker(TripleRelation.SUBJECT), new AliasMap(aliases));
			}

		}
		if (!nodeSets.satisfiable()) {
			return null;
		}
		return new TripleRelationJoiner(nodeSets, newPatterns, newRelations, useAllOptimizations);
	}

	public NodeRelation toNodeRelation() {
		return new NodeRelation(
				joinedBaseRelation().select(
						nodeSets.constraint()).project(nodeSets.allProjections()),
				nodeSets.toMap());
	}

	private Relation joinedBaseRelation() {
		List<Relation> relations = new ArrayList<Relation>();
		for (NodeRelation tripleRelation: joinedTripleRelations) {
			relations.add(tripleRelation.baseRelation());
		}
		return joinRelations(relations, Expression.TRUE);
	}

	/**
	 * Static convenience function that joins several {@link Relation}s into one. Exposed here
	 * because it can be used in the old FastPath engine.
	 *
	 * @param relations A set of {@link Relation}s
	 * @param additionalCondition An additional expression, e.g. join condition
	 * @return A relation that is the join of the inputs
	 */
	private Relation joinRelations(Collection<Relation> relations, Expression additionalCondition) {
		if (relations.isEmpty()) {
			return Relation.TRUE;
		}
		ConnectedDB connectedDB = ((Relation) relations.iterator().next()).database();
		AliasMap joinedAliases = AliasMap.NO_ALIASES;
		Collection<Expression> expressions = new HashSet<Expression>();
		expressions.add(additionalCondition);
		Collection<Expression> softConditions = new HashSet<Expression>();
		Set<Join> joins = new HashSet<Join>();
		Set<ProjectionSpec> projections = new HashSet<ProjectionSpec>();
		int limit = Relation.NO_LIMIT;
		int limitInverse = Relation.NO_LIMIT;
		List<OrderSpec> orderSpecs = null;

		for (Relation relation: relations) {
			joinedAliases = joinedAliases.applyTo(relation.aliases());
			expressions.add(relation.condition());
			softConditions.add(relation.softCondition());
			joins.addAll(relation.joinConditions());
			projections.addAll(relation.projections());
			orderSpecs = orderSpecs == null ? relation.orderSpecs() : orderSpecs;
			limit = Relation.combineLimits(limit, relation.limit());
			limitInverse = Relation.combineLimits(limitInverse, relation.limitInverse());
		}
		// TODO: Determine correct uniqueness instead of just false.
		// The new relation is unique if it is joined only on unique node sets.
		// A node set is unique if it is constrained by only unique node makers.

		// In the meantime, copy the uniqueness from the relation if there's just one
		boolean isUnique = relations.size() == 1 && (relations.iterator().next()).isUnique();
		return new RelationImpl(connectedDB, joinedAliases, Conjunction.create(expressions),
				Conjunction.create(softConditions),
				joins, projections, isUnique, orderSpecs, limit, limitInverse);
	}
}


text:
namespace switches {

// Disables syncing browser data to a Google Account.
const char kDisableSync[] = "disable-sync";

// Disables syncing one or more sync data types that are on by default.
// See sync/base/model_type.h for possible types. Types
// should be comma separated, and follow the naming convention for string
// representation of model types, e.g.:
// --disable-synctypes='Typed URLs, Bookmarks, Autofill Profiles'
const char kDisableSyncTypes[] = "disable-sync-types";

// Enables synchronizing WiFi credentials across devices, using Chrome Sync.
const char kEnableWifiCredentialSync[] = "enable-wifi-credential-sync";

// Enabled the local sync backend implemented by the LoopbackServer.
const char kEnableLocalSyncBackend[] = "enable-local-sync-backend";

// Specifies the local sync backend directory. The name is chosen to mimic
// user-data-dir etc. This flag only matters if the enable-local-sync-backend
// flag is present.
const char kLocalSyncBackendDir[] = "local-sync-backend-dir";

}  // namespace switches


text:
package cmd

import (
	"bytes"
	"fmt"
	"io"
	"os"
	"os/exec"
	"runtime"
	"strings"
	"time"

	"github.com/BurntSushi/toml"
	"github.com/inconshreveable/log15"
	"github.com/knqyf263/gost/config"
	"github.com/knqyf263/gost/db"
	"github.com/knqyf263/gost/models"
	runewidth "github.com/mattn/go-runewidth"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
	"golang.org/x/xerrors"
)

// registerCmd represents the register command
var registerCmd = &cobra.Command{
	Use:   "register",
	Short: "Register CVEs to monitor",
	Long:  `Register CVEs to monitor`,
	RunE:  executeRegister,
}

func init() {
	RootCmd.AddCommand(registerCmd)

	registerCmd.PersistentFlags().String("select-cmd", "fzf", "Select command")
	_ = viper.BindPFlag("select-cmd", registerCmd.PersistentFlags().Lookup("select-cmd"))

	registerCmd.PersistentFlags().String("select-option", "--reverse", "Select command options")
	_ = viper.BindPFlag("select-option", registerCmd.PersistentFlags().Lookup("select-option"))

	registerCmd.PersistentFlags().String("select-after", "", "Show CVEs after the specified date (e.g. 2017-01-01) (default: 30 days ago)")
	_ = viper.BindPFlag("select-after", registerCmd.PersistentFlags().Lookup("select-after"))
}

func executeRegister(cmd *cobra.Command, args []string) (err error) {
	log15.Info("Validate command-line options")
	afterOption := viper.GetString("select-after")
	var after time.Time
	if afterOption != "" {
		if after, err = time.Parse("2006-01-02", afterOption); err != nil {
			return fmt.Errorf("Failed to parse --select-after. err: %s", err)
		}
	} else {
		now := time.Now()
		after = now.Add(time.Duration(-1) * 24 * 30 * time.Hour)
	}

	log15.Info("Load toml config")
	var conf config.Config
	filename := "config.toml"
	if _, err = os.Stat(filename); err == nil {
		_, err = toml.DecodeFile("config.toml", &conf)
		if err != nil {
			return err
		}
	} else {
		conf.Redhat = map[string]config.RedhatWatchCve{}
	}

	log15.Info("Initialize Database")
	driver, locked, err := db.NewDB(viper.GetString("dbtype"), viper.GetString("dbpath"), viper.GetBool("debug-sql"))
	if err != nil {
		if locked {
			log15.Error("Failed to initialize DB. Close DB connection before fetching", "err", err)
		}
		return err
	}

	fetchMeta, err := driver.GetFetchMeta()
	if err != nil {
		log15.Error("Failed to get FetchMeta from DB.", "err", err)
		return err
	}
	if fetchMeta.OutDated() {
		log15.Error("Failed to Insert CVEs into DB. SchemaVersion is old", "SchemaVersion", map[string]uint{"latest": models.LatestSchemaVersion, "DB": fetchMeta.SchemaVersion})
		return xerrors.New("Failed to Insert CVEs into DB. SchemaVersion is old")
	}

	log15.Info("Select all RedHat CVEs")
	allRedhat, err := driver.GetAfterTimeRedhat(after)
	if err != nil {
		return err
	}

	allRedhatText := []string{}
	for _, redhat := range allRedhat {
		if redhat.Name == "" {
			continue
		}
		allRedhatText = append(allRedhatText, fmt.Sprintf("%-16s | %-10s | %-3s | %-24s | %s", redhat.Name, redhat.ThreatSeverity,
			redhat.Cvss3.Cvss3BaseScore, runewidth.Truncate(redhat.GetPackages(","), 20, "..."), runewidth.Truncate(redhat.GetDetail(""), 120, "...")))
	}
	selectedLine, err := filter(allRedhatText)
	var cves []string
	for _, line := range selectedLine {
		split := strings.Split(line, "|")
		if len(split) < 2 {
			continue
		}
		cves = append(cves, strings.TrimSpace(split[0]))
	}

	log15.Info("Register CVEs to watch list")
	for _, cve := range cves {
		_, ok := conf.Redhat[cve]
		if !ok {
			conf.Redhat[cve] = config.RedhatWatchCve{}
		}
	}
	if err = save(conf); err != nil {
		return fmt.Errorf("Failed to save the selected CVEs. err: %s", err)
	}

	return err
}

func run(command string, r io.Reader, w io.Writer) error {
	var cmd *exec.Cmd
	if runtime.GOOS == "windows" {
		cmd = exec.Command("cmd", "/c", command)
	} else {
		cmd = exec.Command("sh", "-c", command)
	}
	cmd.Stderr = os.Stderr
	cmd.Stdout = w
	cmd.Stdin = r
	return cmd.Run()
}

func filter(cves []string) (results []string, err error) {
	var buf bytes.Buffer
	selectCmd := fmt.Sprintf("%s %s",
		viper.GetString("select-cmd"), viper.GetString("select-option"))
	err = run(selectCmd, strings.NewReader(strings.Join(cves, "\n")), &buf)
	if err != nil {
		return nil, nil
	}

	lines := strings.Split(strings.TrimSpace(buf.String()), "\n")

	return lines, nil
}

func save(conf config.Config) error {
	confFile := "config.toml"
	f, err := os.Create(confFile)
	defer f.Close()
	if err != nil {
		return fmt.Errorf("Failed to save config file. err: %s", err)
	}
	return toml.NewEncoder(f).Encode(conf)
}


text:
package io.cattle.platform.archaius.polling;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.netflix.config.FixedDelayPollingScheduler;

public class RefreshableFixedDelayPollingScheduler extends FixedDelayPollingScheduler {

    private static final Logger log = LoggerFactory.getLogger(RefreshableFixedDelayPollingScheduler.class);

    List<Runnable> tasks = new ArrayList<Runnable>();

    public RefreshableFixedDelayPollingScheduler() {
        super();
    }

    public RefreshableFixedDelayPollingScheduler(int initialDelayMillis, int delayMillis, boolean ignoreDeletesFromSource) {
        super(initialDelayMillis, delayMillis, ignoreDeletesFromSource);
    }

    @Override
    protected synchronized void schedule(Runnable runnable) {
        tasks.add(runnable);
        super.schedule(runnable);
    }

    public void refresh() {
        for (Runnable runnable : tasks) {
            try {
                runnable.run();
            } catch (Throwable t) {
                log.error("Failed to reload configuration", t);
            }
        }
    }
}


text:
<?php

use yii\helpers\Html;
use yii\grid\GridView;
use yii\widgets\ActiveForm;

/* @var $this yii\web\View */
/* @var $searchModel app\models\TeachersSearch */
/* @var $dataProvider yii\data\ActiveDataProvider */

$this->title = '讲师列表操作';
$this->params['breadcrumbs'][] = $this->title;
?>

<?= Html::encode($this->title) ?>

    <?php  echo $this->render('_search', ['model' => $searchModel]); ?>

        <?= Html::a('新建讲师', ['create'], ['class' => 'btn btn-success']) ?>

    <?php $form = ActiveForm::begin(['action'=>\yii\helpers\Url::to('/Admin/teachers/del')]); ?>

    <?= GridView::widget([
        'dataProvider' => $dataProvider,
        'filterModel' => $searchModel,
        'columns' => [
            [
                'class' => 'yii\grid\CheckboxColumn',
                'header' => Html::checkBox('selection_all', false, [
                    'class' => 'select-on-check-all',
                ]),
            ],
            'name',
            [
                'attribute' => 'sex',
                'value' => function($searchModel){
                    return app\models\Teachers::getSexName($searchModel->sex);
                }
            ],
            'age',
            [
                'attribute' => 'level',
                'value' => function($searchModel){
                    return app\models\TeachersLevel::getNameById($searchModel->level);
                }
            ],
            [
                'attribute' => 'status',
                'value' => function($searchModel){
                    return app\models\Teachers::getStatusName($searchModel->status);
                }
            ],
            // 'lesson',
            // 'create_time',
            // 'create_user',
            // 'update_time',
            // 'update_user',

            ['class' => 'yii\grid\ActionColumn'],
        ],
    ]); ?>
    <input name="update_status" type="submit" value="删除">
    <?php ActiveForm::end(); ?>


text:
#ifndef _TXMPP_URLENCODE_H_
#define _TXMPP_URLENCODE_H_

#ifndef NO_CONFIG_H
#include "config.h"
#endif

#include <string>

// Decode all encoded characters. Also decode + as space.
int UrlDecode(const char *source, char *dest);

// Decode all encoded characters.
int UrlDecodeWithoutEncodingSpaceAsPlus(const char *source, char *dest);

// Encode all characters except alphas, numbers, and -_.!~*'()
// Also encode space as +.
int UrlEncode(const char *source, char *dest, unsigned max);

// Encode all characters except alphas, numbers, and -_.!~*'()
int UrlEncodeWithoutEncodingSpaceAsPlus(const char *source, char *dest,
                                        unsigned max);

// Encode only unsafe chars, including \ "^&`<>[]{}
// Also encode space as %20, instead of +
int UrlEncodeOnlyUnsafeChars(const char *source, char *dest, unsigned max);

std::string UrlDecodeString(const std::string & encoded);
std::string UrlDecodeStringWithoutEncodingSpaceAsPlus(
    const std::string & encoded);
std::string UrlEncodeString(const std::string & decoded);
std::string UrlEncodeStringWithoutEncodingSpaceAsPlus(
    const std::string & decoded);
std::string UrlEncodeStringForOnlyUnsafeChars(const std::string & decoded);

#endif  // _TXMPP_URLENCODE_H_


text:
#ifndef CYLINDRICALEDGECOUPLE_HH
#define CYLINDRICALEDGECOUPLE_HH
#include "EdgeModel.hh"

EdgeModelPtr CreateCylindricalEdgeCouple(RegionPtr);

// Coupling length
template <typename DoubleType>
class CylindricalEdgeCouple : public EdgeModel {
    public:
        CylindricalEdgeCouple(RegionPtr);

        void Serialize(std::ostream &) const;

    private:
        CylindricalEdgeCouple();
        CylindricalEdgeCouple(const CylindricalEdgeCouple &);
        CylindricalEdgeCouple &operator=(const CylindricalEdgeCouple &);
        void calcCylindricalEdgeCouple2d() const;
        void calcCylindricalEdgeCouple3d() const;
        void calcEdgeScalarValues() const;
};
#endif


text:
	@class RogueHumanoidBindersServer
]=]

local require = require(script.Parent.loader).load(script)

local BinderProvider = require("BinderProvider")
local PlayerHumanoidBinder = require("PlayerHumanoidBinder")

return BinderProvider.new(script.Name, function(self, serviceBag)
	self:Add(PlayerHumanoidBinder.new("RogueHumanoid", require("RogueHumanoid"), serviceBag))
end)


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.camunda.community.process_test_coverage</groupId>
        <artifactId>camunda-process-test-coverage-examples-parent</artifactId>
        <version>2.0.1-SNAPSHOT</version>
    </parent>

    <name>Camunda Process Test Coverage Example JUnit5 Platform 7</name>
    <artifactId>camunda-process-test-coverage-examples-junit5-platform-7</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.camunda.community.process_test_coverage</groupId>
            <artifactId>camunda-process-test-coverage-junit5-platform-7</artifactId>
        </dependency>
        <dependency>
            <groupId>org.camunda.bpm</groupId>
            <artifactId>camunda-engine</artifactId>
        </dependency>
        <dependency>
            <groupId>org.camunda.bpm</groupId>
            <artifactId>camunda-engine-spring</artifactId>
        </dependency>

        <!-- Test Dependencies -->
        <dependency>
            <groupId>org.camunda.bpm.assert</groupId>
            <artifactId>camunda-bpm-assert</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.camunda.community.process_test_coverage</groupId>
                <artifactId>camunda-process-test-coverage-report-aggregator-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>aggregate-reports</id>
                        <goals>
                            <goal>aggregate</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>


text:
package BESA.Mobile.Directory;

import BESA.ExceptionBESA;
import BESA.Kernel.Agent.AgentBESA;
import BESA.Kernel.Agent.Event.EventBESA;
import BESA.Kernel.System.AdmBESA;
import BESA.Kernel.System.Directory.AgHandlerBESA;
import BESA.Mobile.IAdmBPO;
import BESA.Mobile.Message.EventMessageBPO;
import BESA.Mobile.Message.MessageFactoryBPO;

/**
 *
 * @author Andrea Barraza
 */

public class AgHandlerBPO extends AgHandlerBESA{

    private String containerID;

    public AgHandlerBPO(String agId,String alias,String containerID) {
        super(agId, alias);
        this.containerID = containerID;
    }

    public synchronized void sendEvent(EventBESA event, int timeOut) throws ExceptionBESA {
        sendEventAux(event, timeOut);
    }

    @Override
    public synchronized void sendEvent(EventBESA event) throws ExceptionBESA {
        sendEventAux(event, (int) (AdmBESA.getInstance().getConfigBESA()).getSendEventTimeout());
    }

    private synchronized void sendEventAux(EventBESA event, int timeOut) throws ExceptionBESA {
         try {
                //Send Message
                EventMessageBPO message = MessageFactoryBPO.createEventMessage(event, getAgId(),getAlias());
                ((IAdmBPO)AdmBESA.getInstance()).getPostOffice().sendMessageToLocation(containerID, message);
                message.waitForACK(timeOut);
                //Check if message timed out
                if (message.getACK() == null) {
                    ((IAdmBPO)AdmBESA.getInstance()).getPostOffice().messageTimedOut(containerID,message);
                    throw new ExceptionBESA("Message Timed-Out");
                }else
                //Verify Message State
                if (message.getACK().isNegative()) {
                    throw new ExceptionBESA(message.getACK().getExceptionMessage());
                }
            } catch (InterruptedException ex) {
                throw new ExceptionBESA("[AgPostManHandler_BPO] InterruptedException");
            }
    }

    public String getLocation() {
        return containerID;
    }

    @Override
    public AgentBESA getAg(){
        return null;
    }

}


text:
<?php

namespace EvalandgoApiClient\Entity;

use EvalandgoApiClient\OAuth2\OAuth2ClientCredential;
use EvalandgoApiClient\Test\Constants;
use EvalandgoApiClient\Entity\Questionnaire;

class QuestionnaireTest extends \PHPUnit_Framework_TestCase {

    private $cred;
    private $idLastQuestionnaire;
    private $class = 'EvalandgoApiClient\\Entity\\Questionnaire';

    public function setUp() {
        $this->cred = new OAuth2ClientCredential(Constants::CLIENT_ID, Constants::CLIENT_SECRET);
    }

    public function testQuestionnaire() {
        /*$questionnaire = new Questionnaire();

        $this->assertInstanceOf($this->class, $questionnaire);

        $this->assertClassHasAttribute('id', $this->class);
        $this->assertClassHasAttribute('title', $this->class);
        $this->assertClassHasAttribute('close', $this->class);
        $this->assertClassHasAttribute('folder_id', $this->class);
        $this->assertClassHasAttribute('public_url', $this->class);*/
    }

    public function testCreateQuestionnaire() {
        /*$questionnaire = new Questionnaire();
        $questionnaire->setTitle('Test');
        $questionnaire->setClose(false);
        $result = $questionnaire->create($this->cred);

        $this->assertInstanceOf('stdClass', $result);

        $this->idLastQuestionnaire = $questionnaire->getId();*/
    }

    public function testAllQuestionnaire() {
        /*$questionnaires = Questionnaire::all($this->cred);

        $this->assertInternalType('array', $questionnaires);
        $this->assertInstanceOf($this->class, $questionnaires[0]);*/
    }

    public function testGetQuestionnaire() {
        /*$questionnaire = Questionnaire::get($this->idLastQuestionnaire, $this->cred);

        $this->assertInstanceOf($this->class, $questionnaire);*/
    }
}


text:
<?php

namespace Blackfire\Player\Console;

use Blackfire\Player\ExpressionLanguage\ExpressionLanguage;
use Blackfire\Player\ExpressionLanguage\Provider as LanguageProvider;
use Blackfire\Player\Extension\BlackfireExtension;
use Blackfire\Player\Extension\CliFeedbackExtension;
use Blackfire\Player\Extension\TracerExtension;
use Blackfire\Player\Guzzle\Runner;
use Blackfire\Player\Parser;
use Blackfire\Player\Player;
use GuzzleHttp\Client as GuzzleClient;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Formatter\OutputFormatterStyle;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Terminal;

/**
 * @author Fabien Potencier <fabien@symfony.com>
 */
final class PlayerCommand extends Command
{
    protected function configure()
    {
        $this
            ->setName('run')
            ->setDefinition([
                new InputArgument('file', InputArgument::REQUIRED, 'The file defining the scenarios'),
                new InputOption('concurrency', 'c', InputOption::VALUE_REQUIRED, 'The number of clients to create', 1),
                new InputOption('endpoint', '', InputOption::VALUE_REQUIRED, 'Override the scenario endpoint', null),
                new InputOption('json', '', InputOption::VALUE_NONE, 'Outputs variable values as JSON', null),
                new InputOption('variable', '', InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY, 'Override a variable value', null),
                new InputOption('validate', '', InputOption::VALUE_NONE, 'Validate syntax without running', null),
                new InputOption('tracer', '', InputOption::VALUE_NONE, 'Store debug information on disk', null),
                new InputOption('blackfire-env', '', InputOption::VALUE_REQUIRED, 'The blackfire environment to use'),
            ])
            ->setDescription('Runs scenario files')
            ->setHelp('Read https://blackfire.io/docs/player to learn about all supported options.')
        ;
    }

    protected function initialize(InputInterface $input, OutputInterface $output)
    {
        $output->getFormatter()->setStyle('title', new OutputFormatterStyle('black', 'yellow'));
        $output->getFormatter()->setStyle('debug', new OutputFormatterStyle('red', 'black'));
        $output->getFormatter()->setStyle('failure', new OutputFormatterStyle('white', 'red'));
        $output->getFormatter()->setStyle('success', new OutputFormatterStyle('white', 'green'));
        $output->getFormatter()->setStyle('detail', new OutputFormatterStyle('white', 'blue'));
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $clients = [$this->createClient($output)];
        $concurrency = $input->getOption('concurrency');
        for ($i = 1; $i < $concurrency; ++$i) {
            $clients[] = $this->createClient($output);
        }

        $runner = new Runner($clients);

        $language = new ExpressionLanguage(null, [new LanguageProvider()]);
        $player = new Player($runner, $language);
        $player->addExtension(new BlackfireExtension($language, $input->getOption('blackfire-env'), $output), 510);
        if (!$input->getOption('json')) {
            $player->addExtension(new CliFeedbackExtension($output, (new Terminal())->getWidth()));
        }
        if ($input->getOption('tracer')) {
            $player->addExtension(new TracerExtension($output));
        }

        $variables = [];
        foreach ($input->getOption('variable') as $variable) {
            list($key, $value) = explode('=', $variable, 2);
            $variables[$key] = $value;
        }

        $parser = new Parser();
        $scenarios = $parser->load($input->getArgument('file'));

        // FIXME: should be set on the ScenarioSet directly
        // but for this, we need an enterStep() for the ScenarioSet, which we don't have yet
        foreach ($scenarios as $scenario) {
            if (null !== $input->getOption('endpoint')) {
                $scenario->endpoint($this->escapeValue($input->getOption('endpoint')));
            }

            foreach ($parser->getGlobalVariables() as $key => $value) {
                // Override only if the endpoint is not already defined in the step
                if ($key === 'endpoint' && null === $scenario->getEndpoint() && null === $input->getOption('endpoint')) {
                    $scenario->endpoint($this->escapeValue($value));
                }

                $scenario->set($key, $this->escapeValue($value));
            }

            foreach ($variables as $key => $value) {
                $scenario->set($key, $this->escapeValue($value));
            }
        }

        if ($input->getOption('validate')) {
            $output->writeln('<info>The scenarios are valid.</>');

            return;
        }

        $results = $player->run($scenarios);

        if ($input->getOption('json')) {
            $output->writeln(json_encode($results->getValues(), JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
        }

        // any scenario with an error?
        if ($results->isErrored()) {
            return 1;
        }
    }

    private function createClient(OutputInterface $output)
    {
        return new GuzzleClient(['cookies' => true, 'allow_redirects' => false, 'http_errors' => false]);
    }

    private function escapeValue($value)
    {
        return sprintf("'%s'", $value);
    }
}


text:
This module calculates an urban mixed-use measure based on the 2001 National Household Travel Survey measure of the tract level urban/rural indicator. This measure developed by Claritas uses the density of the tract and surrounding tracts to identify the urban/rural context of the tract. The categories include urban, suburban, second city, town and rural. Mapping of example metropolitan areas shows that places shown as urban correspond to central city and inner neighborhoods characterized by mixed use, higher levels of urban accessibility, and higher levels of walk/bike/transit accessibility.

## Model Parameter Estimation

A binary logit model is used to calculate the probability that a household is located in an urban mixed-use neighborhood as a function of the population density of the Bzone that household resides in and the housing type of the household.

This model is estimated using a household dataset prepared from 2001 National Household Travel Survey public use datasets by the VE2001NHTS package. The HhData_df data frame is loaded from that package and used to estimate the model. Following are the summary statistics for the estimated model:

```

Call:
glm(formula = makeFormula(StartTerms_), family = binomial, data = EstData_df)

Deviance Residuals:
    Min       1Q   Median       3Q      Max
-2.7300  -0.2690  -0.2233  -0.1863   2.8505

Coefficients:
                  Estimate Std. Error z value Pr(>|z|)
(Intercept)     -3.865e+00  4.508e-02 -85.729  < 2e-16 ***
LocalPopDensity  2.522e-04  2.753e-06  91.618  < 2e-16 ***
IsSF            -1.929e-01  4.074e-02  -4.734  2.2e-06 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

(Dispersion parameter for binomial family taken to be 1)

    Null deviance: 41217  on 60499  degrees of freedom
Residual deviance: 23154  on 60497  degrees of freedom
AIC: 23160

Number of Fisher Scoring iterations: 6

```

The results of applying the binomial logit model are optionally constrained to match a target proportion that the user may input for the Bzone. This is done by successively adjusting the intercept of the model using a binary search algorithm.

## How the Module Works

For each household in each Bzone, the binomial logit model predicts the probability that the household resides in an urban mixed-use neighborhood. Random sampling using the probability determines whether the household is identified as residing in an urban mixed-use neighborhood. If a target proportion for the Bzone has been supplied by the user, the model is run repeatedly for households in the Bzone using a binary search algorithm to adjust the model intercept so that the modeled proportion is equal to the target.

## User Inputs
The following table(s) document each input file that must be provided in order for the module to run correctly. User input files are comma-separated valued (csv) formatted text files. Each row in the table(s) describes a field (column) in the input file. The table names and their meanings are as follows:

NAME - The field (column) name in the input file. Note that if the 'TYPE' is 'currency' the field name must be followed by a period and the year that the currency is denominated in. For example if the NAME is 'HHIncomePC' (household per capita income) and the input values are in 2010 dollars, the field name in the file must be 'HHIncomePC.2010'. The framework uses the embedded date information to convert the currency into base year currency amounts. The user may also embed a magnitude indicator if inputs are in thousand, millions, etc. The VisionEval model system design and users guide should be consulted on how to do that.

TYPE - The data type. The framework uses the type to check units and inputs. The user can generally ignore this, but it is important to know whether the 'TYPE' is 'currency'

UNITS - The units that input values need to represent. Some data types have defined units that are represented as abbreviations or combinations of abbreviations. For example 'MI/HR' means miles per hour. Many of these abbreviations are self evident, but the VisionEval model system design and users guide should be consulted.

PROHIBIT - Values that are prohibited. Values may not meet any of the listed conditions.

ISELEMENTOF - Categorical values that are permitted. Value must be one of the listed values.

UNLIKELY - Values that are unlikely. Values that meet any of the listed conditions are permitted but a warning message will be given when the input data are processed.

DESCRIPTION - A description of the data.

### bzone_urban-mixed-use_prop.csv
|NAME       |TYPE   |UNITS      |PROHIBIT |ISELEMENTOF |UNLIKELY |DESCRIPTION                                                                                |
|:----------|:------|:----------|:--------|:-----------|:--------|:---------------------------------------------------------------------------------------------------|
|Geo        |       |           |         |Bzones      |         |Must contain a record for each Bzone and model run year.                                            |
|Year       |       |           |         |            |         |Must contain a record for each Bzone and model run year.                                            |
|MixUseProp |double |proportion |< 0, > 1 |            |         |Target for proportion of households located in mixed-use neighborhoods in zone (or NA if no target) |

## Datasets Used by the Module
The following table documents each dataset that is retrieved from the datastore and used by the module. Each row in the table describes a dataset. All the datasets must be present in the datastore. One or more of these datasets may be entered into the datastore from the user input files. The table names and their meanings are as follows:

NAME - The dataset name.

TABLE - The table in the datastore that the data is retrieved from.

GROUP - The group in the datastore where the table is located. Note that the datastore has a group named 'Global' and groups for every model run year. For example, if the model run years are 2010 and 2050, then the datastore will have a group named '2010' and a group named '2050'. If the value for 'GROUP' is 'Year', then the dataset will exist in each model run year group. If the value for 'GROUP' is 'BaseYear' then the dataset will only exist in the base year group (e.g. '2010'). If the value for 'GROUP' is 'Global' then the dataset will only exist in the 'Global' group.

TYPE - The data type. The framework uses the type to check units and inputs. Refer to the model system design and users guide for information on allowed types.

UNITS - The units that input values need to represent. Some data types have defined units that are represented as abbreviations or combinations of abbreviations. For example 'MI/HR' means miles per hour. Many of these abbreviations are self evident, but the VisionEval model system design and users guide should be consulted.

PROHIBIT - Values that are prohibited. Values in the datastore do not meet any of the listed conditions.

ISELEMENTOF - Categorical values that are permitted. Values in the datastore are one or more of the listed values.

|NAME       |TABLE     |GROUP |TYPE       |UNITS      |PROHIBIT |ISELEMENTOF |
|:----------|:---------|:-----|:----------|:----------|:--------|:-----------|
|Bzone      |Bzone     |Year  |character  |ID         |         |            |
|NumHh      |Bzone     |Year  |households |HH         |NA, < 0  |            |
|UrbanPop   |Bzone     |Year  |people     |PRSN       |NA, <= 0 |            |
|TownPop    |Bzone     |Year  |people     |PRSN       |NA, <= 0 |            |
|RuralPop   |Bzone     |Year  |people     |PRSN       |NA, <= 0 |            |
|UrbanArea  |Bzone     |Year  |area       |SQMI       |NA, < 0  |            |
|TownArea   |Bzone     |Year  |area       |SQMI       |NA, < 0  |            |
|RuralArea  |Bzone     |Year  |area       |SQMI       |NA, < 0  |            |
|MixUseProp |Bzone     |Year  |double     |proportion |< 0, > 1 |            |
|Bzone      |Household |Year  |character  |ID         |         |            |
|HhId       |Household |Year  |character  |ID         |         |            |
|HouseType  |Household |Year  |character  |category   |         |SF, MF, GQ  |

## Datasets Produced by the Module
The following table documents each dataset that is retrieved from the datastore and used by the module. Each row in the table describes a dataset. All the datasets must be present in the datastore. One or more of these datasets may be entered into the datastore from the user input files. The table names and their meanings are as follows:

NAME - The dataset name.

TABLE - The table in the datastore that the data is retrieved from.

GROUP - The group in the datastore where the table is located. Note that the datastore has a group named 'Global' and groups for every model run year. For example, if the model run years are 2010 and 2050, then the datastore will have a group named '2010' and a group named '2050'. If the value for 'GROUP' is 'Year', then the dataset will exist in each model run year. If the value for 'GROUP' is 'BaseYear' then the dataset will only exist in the base year group (e.g. '2010'). If the value for 'GROUP' is 'Global' then the dataset will only exist in the 'Global' group.

TYPE - The data type. The framework uses the type to check units and inputs. Refer to the model system design and users guide for information on allowed types.

UNITS - The units that input values need to represent. Some data types have defined units that are represented as abbreviations or combinations of abbreviations. For example 'MI/HR' means miles per hour. Many of these abbreviations are self evident, but the VisionEval model system design and users guide should be consulted.

PROHIBIT - Values that are prohibited. Values in the datastore do not meet any of the listed conditions.

ISELEMENTOF - Categorical values that are permitted. Values in the datastore are one or more of the listed values.

DESCRIPTION - A description of the data.

|NAME            |TABLE     |GROUP |TYPE    |UNITS  |PROHIBIT |ISELEMENTOF |DESCRIPTION                                                                             |
|:---------------|:---------|:-----|:-------|:------|:--------|:-----------|:---------------------------------------------------------------------------------------|
|IsUrbanMixNbrhd |Household |Year  |integer |binary |NA       |0, 1        |Flag identifying whether household is (1) or is not (0) in urban mixed-use neighborhood |


text:
cask 'multitouch' do
  version '1.15.2'
  sha256 'd0e1afc92ad014548303e623a5634f529bac150eeb389e5e3c67630da3feb105'

  url "https://multitouch.app/downloads/multitouch#{version}.dmg"
  appcast 'https://www.multitouch.app/downloads/updates.xml'
  name 'Multitouch'
  homepage 'https://multitouch.app/'

  auto_updates true
  depends_on macos: '>= :sierra'

  app 'Multitouch.app'

  zap trash: [
               '~/Library/Preferences/com.brassmonkery.Multitouch',
               '~/Library/Application Support/Multitouch',
               '~/Library/Caches/com.brassmonkery.Multitouch',
             ]
end


text:
package at.ac.tuwien.dsg.salam.common.sla.comparator;

import java.util.Comparator;

public class NumericDescendingComparator implements Comparator<Object> {

    public int compare(Object o1, Object o2) {
        Double val1 = (Double)o1;
        Double val2 = (Double)o2;
        return val2.compareTo(val1);
    }

}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Class twitter4j.HttpRequest (twitter4j-core 4.0.5-SNAPSHOT API)</title>
<meta name="date" content="2016-04-24">
<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Uses of Class
twitter4j.HttpRequest

Packages that use HttpRequest

Package
Description

twitter4j

general package for Twitter4J

twitter4j.auth

OAuth related classes

Uses of HttpRequest in twitter4j

Methods in twitter4j that return HttpRequest

Modifier and Type
Method and Description

HttpRequest
HttpResponseEvent.getRequest()

returns the request associated with the event

Methods in twitter4j with parameters of type HttpRequest

Modifier and Type
Method and Description

String
XAuthAuthorization.getAuthorizationHeader(HttpRequest req)

HttpResponse
HttpClientBase.request(HttpRequest req)

HttpResponse
HttpClient.request(HttpRequest req)

HttpResponse
HttpClientBase.request(HttpRequest req,
       HttpResponseListener listener)

HttpResponse
HttpClient.request(HttpRequest req,
       HttpResponseListener listener)

Uses of HttpRequest in twitter4j.auth

Methods in twitter4j.auth with parameters of type HttpRequest

Modifier and Type
Method and Description

String
OAuthAuthorization.getAuthorizationHeader(HttpRequest req)

String
OAuth2Authorization.getAuthorizationHeader(HttpRequest req)

String
NullAuthorization.getAuthorizationHeader(HttpRequest req)

String
BasicAuthorization.getAuthorizationHeader(HttpRequest req)

String
Authorization.getAuthorizationHeader(HttpRequest req)

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Copyright © 2016. All rights reserved.


text:
namespace IO
{
	__IODefineIOCoreMeta(Number, Object)

#define NumberPrimitiveAccess(type, target) static_cast<target>(*((type *)_buffer))
#define NumberIsSignedInteger(type) (type == Type::Int8 || type == Type::Int16 || type == Type::Int32 || type == Type::Int64)
#define NumberIsUnsignedInteger(type) (type == Type::Uint8 || type == Type::Uint16 || type == Type::Uint32 || type == Type::Uint64)
#define NumberIsBoolean(type) (type == Type::Boolean)

#define NumberAccessAndConvert(var, type) \
	do { \
		switch(_type) \
		{ \
			case Type::Boolean: \
				var = NumberPrimitiveAccess(bool, type); \
				break; \
			case Type::Int8: \
				var = NumberPrimitiveAccess(int8_t, type); \
				break; \
			case Type::Uint8: \
				var = NumberPrimitiveAccess(uint8_t, type); \
				break; \
			case Type::Int16: \
				var = NumberPrimitiveAccess(int16_t, type); \
				break; \
			case Type::Uint16: \
				var = NumberPrimitiveAccess(uint16_t, type); \
				break; \
			case Type::Int32: \
				var = NumberPrimitiveAccess(int32_t, type); \
				break; \
			case Type::Uint32: \
				var = NumberPrimitiveAccess(uint32_t, type); \
				break; \
			case Type::Int64: \
				var = NumberPrimitiveAccess(int64_t, type); \
				break; \
			case Type::Uint64: \
				var = NumberPrimitiveAccess(uint64_t, type); \
				break; \
			} \
		} while(0)

	Number *Number::InitWithBool(bool value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(bool), Type::Boolean);
		return this;
	}

	Number *Number::InitWithInt8(int8_t value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(int8_t), Type::Int8);
		return this;
	}
	Number *Number::InitWithInt16(int16_t value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(int16_t), Type::Int16);
		return this;
	}
	Number *Number::InitWithInt32(int32_t value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(int32_t), Type::Int32);
		return this;
	}
	Number *Number::InitWithInt64(int64_t value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(int64_t), Type::Int64);
		return this;
	}

	Number *Number::InitWithUint8(uint8_t value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(uint8_t), Type::Uint8);
		return this;
	}
	Number *Number::InitWithUint16(uint16_t value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(uint16_t), Type::Uint16);
		return this;
	}
	Number *Number::InitWithUint32(uint32_t value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(uint32_t), Type::Uint32);
		return this;
	}
	Number *Number::InitWithUint64(uint64_t value)
	{
		if(!Object::Init())
			return nullptr;

		CopyData(&value, sizeof(uint64_t), Type::Uint64);
		return this;
	}

	void Number::Dealloc()
	{
		delete [] _buffer;
		Object::Dealloc();
	}

	void Number::CopyData(const void *data, size_t size, Type type)
	{
		const uint8_t *source = static_cast<const uint8_t *>(data);

		_buffer = new uint8_t[size];
		_type = type;

		std::copy(source, source + size, _buffer);
	}

	bool Number::GetBoolValue() const
	{
		bool value;
		NumberAccessAndConvert(value, bool);

		return value;
	}

	int8_t Number::GetInt8Value() const
	{
		int8_t value;
		NumberAccessAndConvert(value, int8_t);

		return value;
	}
	int16_t Number::GetInt16Value() const
	{
		int16_t value;
		NumberAccessAndConvert(value, int16_t);

		return value;
	}
	int32_t Number::GetInt32Value() const
	{
		int32_t value;
		NumberAccessAndConvert(value, int32_t);

		return value;
	}
	int64_t Number::GetInt64Value() const
	{
		int64_t value;
		NumberAccessAndConvert(value, int64_t);

		return value;
	}

	uint8_t Number::GetUint8Value() const
	{
		uint8_t value;
		NumberAccessAndConvert(value, uint8_t);

		return value;
	}
	uint16_t Number::GetUint16Value() const
	{
		uint16_t value;
		NumberAccessAndConvert(value, uint16_t);

		return value;
	}
	uint32_t Number::GetUint32Value() const
	{
		uint32_t value;
		NumberAccessAndConvert(value, uint32_t);

		return value;
	}
	uint64_t Number::GetUint64Value() const
	{
		uint64_t value;
		NumberAccessAndConvert(value, uint64_t);

		return value;
	}

	size_t Number::SizeForType(Type type)
	{
		switch(type)
		{
			case Type::Int8:
			case Type::Uint8:
				return 1;

			case Type::Int16:
			case Type::Uint16:
				return 2;

			case Type::Int32:
			case Type::Uint32:
				return 4;

			case Type::Int64:
			case Type::Uint64:
				return 8;

			case Type::Boolean:
				return sizeof(bool);
		}

		panic("Number::SizeForType() Unknown type!");
	}

	size_t Number::GetHash() const
	{
		const uint8_t *bytes = _buffer;
		const uint8_t *end = bytes + SizeForType(_type);

		size_t hash = 0;

		while(bytes < end)
		{
			hash ^= (hash << 5) + (hash >> 2) + *bytes;
			bytes ++;
		}

		return hash;
	}
	bool Number::IsEqual(Object *other) const
	{
		Number *number = other->Downcast<Number>();
		if(!number)
			return false;

		bool integer = ((NumberIsSignedInteger(_type) || NumberIsUnsignedInteger(_type)) && (NumberIsSignedInteger(number->_type) || NumberIsUnsignedInteger(number->_type)));
		if(integer)
		{
			if((NumberIsSignedInteger(_type) && NumberIsSignedInteger(number->_type)) || (NumberIsUnsignedInteger(_type) && NumberIsUnsignedInteger(number->_type)))
			{
				return (GetUint64Value() == number->GetUint64Value());
			}

			uint64_t uint = (NumberIsSignedInteger(_type)) ? number->GetUint64Value() : GetUint64Value();
			if(uint > INT64_MAX)
				return false;

			int64_t  sint = (NumberIsSignedInteger(_type)) ? GetInt64Value() : number->GetInt64Value();
			return (sint == static_cast<int64_t>(uint));
		}

		if(NumberIsBoolean(_type) && NumberIsBoolean(number->_type))
		{
			return (GetBoolValue() == number->GetBoolValue());
		}

		return false;
	}

#undef NumberPrimitiveAccess
#undef NumberAccessAndConvert
}


text:
<?php
// Copyright (c) 2010 The Fajr authors (see AUTHORS).
// Use of this source code is governed by a MIT license that can be
// found in the LICENSE file in the project root directory.

/**
 *
 * @package    Libfajr
 * @subpackage Login
 * @author     Martin Králik <majak47@gmail.com>
 * @author     Martin Sucha <anty.sk@gmail.com>
 * @filesource
 */
namespace libfajr\login;
use libfajr\connection\HttpConnection;
use libfajr\login\CosignServiceCookie;
use libfajr\trace\NullTrace;
use libfajr\exceptions\NotImplementedException;
use libfajr\exceptions\LoginException;
use libfajr\AIS2ServerInstance;
use libfajr\connection\AIS2ServerConnection;
use libfajr\connection\AIS2ServerUrlMap;

/**
 * Trieda reprezentujúca prihlasovanie pomocou cookie
 *
 * @package    Libfajr
 * @subpackage Login
 * @author     Martin Králik <majak47@gmail.com>
 * @author     Martin Sucha <anty.sk@gmail.com>
 */
class CosignCookieLogin extends CosignAbstractLogin
{
  /** @var CosignServiceCookie $cookie */
  protected $cookie = null;

  public function  __construct(CosignServiceCookie $cookie)
  {
    $this->cookie = $cookie;
  }

  public function login(AIS2ServerConnection $serverConnection)
  {
    $connection = $serverConnection->getHttpConnection();
    $connection->addCookie($this->cookie->getName(), $this->cookie->getValue(),
                           0, '/', $this->cookie->getDomain());
    return true;
  }

  public function isLoggedIn(AIS2ServerConnection $unused)
  {
    throw new NotImplementedException("We are not able to verify cosign service cookie.");
  }
}


text:
"""Gumbel bijector."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

# go/tf-wildcard-import
# pylint: disable=wildcard-import
from tensorflow.contrib.distributions.python.ops.bijectors.gumbel_impl import *
# pylint: enable=wildcard-import
from tensorflow.python.util.all_util import remove_undocumented

_allowed_symbols = ["Gumbel"]

remove_undocumented(__name__, _allowed_symbols)


text:
FROM golang:1.18.4 AS builder

RUN mkdir /build

COPY . /build/

WORKDIR /build

RUN  --mount=type=cache,target=/go/pkg/mod \
  --mount=type=cache,target=/root/.cache/go-build \
  GOARCH=$BUILDPLATFORM CGO_ENABLED=0 GOOS=linux go build -o isotope_service ./service

FROM alpine:3.12

COPY --from=builder /build/isotope_service /usr/local/bin/isotope_service

EXPOSE 8080

ENTRYPOINT ["/usr/local/bin/isotope_service"]


text:
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    android:id="@+id/now_parent"
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@color/colorPrimary">

    <android.support.constraint.Guideline
        android:id="@+id/now_guideline"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        app:layout_constraintGuide_percent="0.5"
        />
    <!--
        <TextView
            android:id="@+id/now_location"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textColor="@android:color/white"
            android:textSize="24sp"
            app:layout_constraintBottom_toTopOf="@+id/now_description"
            app:layout_constraintLeft_toLeftOf="@id/now_parent"
            app:layout_constraintRight_toLeftOf="@id/now_guideline"
            app:layout_constraintTop_toTopOf="@id/now_parent"
            tools:text="Hrodna"
            />

        <TextView
            android:id="@+id/now_description"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textColor="@android:color/white"
            android:textSize="14sp"
            app:layout_constraintBottom_toBottomOf="@id/now_parent"
            app:layout_constraintLeft_toLeftOf="@id/now_location"
            app:layout_constraintRight_toRightOf="@id/now_location"
            app:layout_constraintTop_toBottomOf="@id/now_location"
            tools:text="Clear"
            />

        <ImageView
            android:id="@+id/now_image_weather"
            android:layout_width="90dp"
            android:layout_height="90dp"
            app:layout_constraintLeft_toRightOf="@id/now_guideline"
            app:layout_constraintRight_toLeftOf="@+id/now_temp"
            app:layout_constraintBottom_toBottomOf="@id/now_parent"
            app:layout_constraintTop_toTopOf="@id/now_parent"
            tools:src="@drawable/art_clear"/>

        <TextView
            android:id="@+id/now_temp"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textColor="@android:color/white"
            android:textSize="56sp"
            app:layout_constraintBottom_toBottomOf="@id/now_parent"
            app:layout_constraintLeft_toRightOf="@id/now_image_weather"
            app:layout_constraintRight_toRightOf="@id/now_parent"
            app:layout_constraintTop_toTopOf="@id/now_parent"
            tools:text="22\u00b0"
            />-->

    <TextView
        android:id="@+id/now_location"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textColor="@android:color/white"
        android:textSize="30sp"
        app:layout_constraintLeft_toLeftOf="@+id/now_guideline"
        app:layout_constraintRight_toLeftOf="@+id/now_guideline"
        app:layout_constraintTop_toTopOf="parent"
        tools:layout_editor_absoluteY="0dp"
        tools:text="Hrodna"/>

    <TextView
        android:id="@+id/now_description"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textColor="@android:color/white"
        android:textSize="18sp"
        app:layout_constraintLeft_toLeftOf="@+id/now_guideline"
        app:layout_constraintRight_toLeftOf="@+id/now_guideline"
        app:layout_constraintTop_toBottomOf="@+id/now_location"
        tools:text="Clear"/>

    <ImageView
        android:id="@+id/now_image_weather"
        android:layout_width="90dp"
        android:layout_height="90dp"
        android:layout_marginTop="10dp"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toLeftOf="@+id/now_guideline"
        app:layout_constraintTop_toBottomOf="@+id/now_description"
        tools:src="@drawable/art_clear"/>

    <TextView
        android:id="@+id/now_temp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:textColor="@android:color/white"
        android:textSize="77sp"
        app:layout_constraintBottom_toBottomOf="@id/now_image_weather"
        app:layout_constraintLeft_toRightOf="@id/now_guideline"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toBottomOf="@id/now_description"
        tools:text="22\u00b0"/>

</android.support.constraint.ConstraintLayout>


text:
S2GX.View.extend({
  name: 's2gx/Sessions',
  events: {
	  "click .listitem" : "sessionClicked"
  },

  sessionClicked : function(e) {
	  sessionId = e.currentTarget.attributes[0].value;
	  S2GX.Routers.s2gx.navigate('/session/' + sessionId, { trigger: true })
  }

});


text:
/**
 *     This code was auto-generated by a Codezu.
 *
 *     Changes to this file may cause incorrect behavior and will be lost if
 *     the code is regenerated.
 */
package com.mozu.api.contracts.productadmin;

import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import org.joda.time.DateTime;
import java.io.IOException;
import java.lang.ClassNotFoundException;

/**
 *	Properties of the attribute type rule.
 */
@JsonIgnoreProperties(ignoreUnknown = true)
public class AttributeTypeRule implements Serializable
{
	// Default Serial Version UID
	private static final long serialVersionUID = 1L;

	/**
	 * The data type of the attribute. There are four valid data types: "Bool", "DateTime", "Number", "String"
	 */
	protected  String attributeDataType;

	public String getAttributeDataType() {
		return this.attributeDataType;
	}

	public void setAttributeDataType(String attributeDataType) {
		this.attributeDataType = attributeDataType;
	}

	/**
	 * An attribute's data type would be either "NotSpecified", "Textbox", "Textarea", "Date", "DateTime", "Dropdown", "Listbox", "Radio", "Currency", or "Checkbox" and will be a valid value defined in the type rules resource.
	 */
	protected  String attributeInputType;

	public String getAttributeInputType() {
		return this.attributeInputType;
	}

	public void setAttributeInputType(String attributeInputType) {
		this.attributeInputType = attributeInputType;
	}

	/**
	 * Describes how an attribute will be used. Valid types are "Extra", "Option", and "Property".
	 */
	protected  String attributeUsageType;

	public String getAttributeUsageType() {
		return this.attributeUsageType;
	}

	public void setAttributeUsageType(String attributeUsageType) {
		this.attributeUsageType = attributeUsageType;
	}

	/**
	 * An attribute value type is either predefined vocabulary by the admin during product attribute set up or it can be "AdminEntered" or "ShopperEntered". The difference between predefined values versus manually entered values is such that the first choice is a set of options to choose from. AdminEntered and ShopperEntered are values that are entered rather than system-supplied and are not stored in the database, but captured during a live commerce operations such as during an order.
	 */
	protected  String attributeValueType;

	public String getAttributeValueType() {
		return this.attributeValueType;
	}

	public void setAttributeValueType(String attributeValueType) {
		this.attributeValueType = attributeValueType;
	}

}


text:
package eu.socialsensor.framework.client.mongo;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;

import eu.socialsensor.framework.common.domain.JSONable;

public class Selector implements JSONable {

	Map<Object, Object> and = null;

	public void select(Object field, Object value) {
		if(and == null)
			and = new HashMap<Object, Object>();
		and.put(field, value);
	}

	public void exists(Object field) {
		if(and == null)
			and = new HashMap<Object, Object>();
		Map<String, Boolean> temp = new HashMap<String, Boolean>();
		temp.put("$exists", Boolean.TRUE);
		and.put(field, temp);
	}

	public void selectGreaterThan(Object field, Object value) {
		if(and == null)
			and = new HashMap<Object, Object>();
		@SuppressWarnings("unchecked")
		Map<Object, Object> op = (Map<Object, Object>) and.get(field);
		if(op == null)
			op = new HashMap<Object, Object>();
		op.put("$gte", value);
		and.put(field, op);
	}

	public void selectLessThan(Object field, Object value) {
		if(and == null)
			and = new HashMap<Object, Object>();
		@SuppressWarnings("unchecked")
		Map<Object, Object> op = (Map<Object, Object>) and.get(field);
		if(op == null)
			op = new HashMap<Object, Object>();
		op.put("$lt", value);
		and.put(field, op);
	}

	@Override
	public String toJSONString() {
		Gson gson = new GsonBuilder()
        	.excludeFieldsWithoutExposeAnnotation()
        	.registerTypeAdapter(Selector.class, new SelectorSerializer())
        	.create();
		return gson.toJson(this);
	}

	public static void main(String[] args) {
		Selector selector = new Selector();
		selector.select("id", "32123437523234788965");
		selector.select("timeslotId", "34glppjv02vpd");
		selector.select("source", "Twitter");
		selector.selectGreaterThan("pubDate", "12-01-2012");
		selector.selectLessThan("pubDate", "12-12-2012");
		System.out.println(selector.toJSONString());
	}

	public class SelectorSerializer extends TypeAdapter<Selector> {
	    @Override
	    public void write(JsonWriter out, Selector selector) throws IOException {
	    	out.beginObject();
	    	Map<Object, Object> fields = selector.and;
	    	if(fields==null){
	    		out.endObject();
	    		return;
	    	}
	    	for(Entry<Object, Object> entry : fields.entrySet()) {
	    		Object key = entry.getKey();
	    		Object value = entry.getValue()	;

	    		out.name(key.toString());
	    		if(value instanceof String) {
    				out.value(value.toString());
	    		} else if(value instanceof Long) {
    				out.value((Long)value);
    			}
    			else if (value instanceof Boolean) {
    				out.value((Boolean)value);
	    		} else if(value instanceof Map){
	    			out.beginObject();
	    			@SuppressWarnings("unchecked")
					Map<Object, Object> op = (Map<Object, Object>) value;

	    			for(Entry<Object, Object> f : op.entrySet()) {
	    				out.name(f.getKey().toString());
	    				Object v = f.getValue();
	    				if(v instanceof String)
	    					out.value(v.toString());
	    				else if(v instanceof Long)
	    					out.value((Long)v);
	    				else if (v instanceof Boolean)
	    					out.value((Boolean)v);
	    			}
	    			out.endObject();
	    		}
	    	}
	    	out.endObject();
	    }

	    @Override
	    public Selector read(JsonReader in) throws IOException {
	        return null;
	    }
	}
}


text:
/**
 * @flow
 */

var EventHandler = require('./EventHandler.js');

var uniqueID = require('../uniqueid/uniqueID.js');

class Event {

  _handlers: {[key:number]: Function};

  constructor() {
    this._handlers = {};
  }

  /**
   * Add a subscription to this event
   *
   * @param  callback  run when the event is triggered.
   * @return this
   */
  addHandler(callback: Function): EventHandler {
    var key = uniqueID();
    this._handlers[key] = callback;
    return new EventHandler(this, key);
  }

  /**
   * Destroys this event. Removes all handlers.
   *
   * @return this
   */
  remove(): Event {
    this._handlers = {};
    return this;
  }

  /**
   * Removes a subscription by key.
   *
   * @param  key   id of the subscription to remove
   * @return this
   */
  removeHandler(key: number): Event {
    delete this._handlers[key];
    return this;
  }

  /**
   * @protected
   * Run a handler by key if it exists
   *
   * @param  key  id of the handler to run
   */
  _runHandler(key: number): void {
    if (this._handlers.hasOwnProperty(key)) {
      this._handlers[key].call();
    }
  }

  /**
   * Run all subscribed handlers.
   *
   * @return this
   */
  runHandlers(): Event {
    Object.keys(this._handlers).forEach(this._runHandler.bind(this));
    return this;
  }

}

/**
 * Convenience method for running multiple events.
 *
 * @param  events  a list of events to run.
 */
Event.runMultiple = function (events: Array<Event>): void {
  events.forEach(evt => evt.runHandlers());
};

module.exports = Event;


text:
title: "About"
layout: "page"
---
### The blog theme you may fall in love with, coming to Hexo. [Preview](http://ppoffice.github.io/hexo-theme-icarus/)
![](http://ppoffice.github.io/hexo-theme-icarus/gallery/preview.jpg "")

## Installation

### Install

``` bash
$ git clone https://github.com/ppoffice/hexo-theme-icarus.git themes/icarus
```

**Icarus requires Hexo 3.0 and above.**

### Enable

1. Rename `themes\icarus\_config.yml.example` to `themes\icarus\_config.yml`;
2. Copy `themes\icarus\_config.yml.site.example` to your hexo blog's root directory and rename it to `_config.yml`;
3. Copy `themes\icarus\_source\*` into your hexo blog's directory `source`;
4. Then modify `theme` setting in `_config.yml` to `icarus`.

### Update

``` bash
cd themes/icarus
git pull
```

## Configuration

### Theme configuration example
```r
# Header
menu:
  Home: .
  Archives: archives
  Categories: categories # you need to add extra page to enable this, please see the config below.
  Tags: tags             # you need to add extra page to enable this, please see the config below.
  About: about

# Content
excerpt_link: Read More
fancybox: true

# Sidebar
sidebar: right
widgets:
- recent_posts
- category
- tag
- tagcloud
- archive
thumbnail: true

# Contacts
contacts:
  github: http://github.com/ppoffice/hexo-theme-icarus
  twitter: '#'
  facebook: '#'
  dribbble: '#'
  rss: atom.xml

# Links
links:
  Hexo: http://hexo.io

# Miscellaneous
google_analytics:
favicon: favicon.png
twitter:
google_plus:
fb_admins:
fb_app_id:
```

- **excerpt_link** - Cooperate with `<!-- more -->` tag to show only part of the article in index pages.
- **fancybox** - Enable [Fancybox].
- **contacts** - Your social network links, RSS link, etc.
- **widgets** - Widgets displaying in sidebar.
- **thumbnail** - Whether to show post thumbnails in the sidebar and archive pages.
- **links** - Links displayed in the link widget.
- **google_analytics** - Google Analytics ID.
- **favicon** - Favicon path.

### Site configuration example
```r
# Site
title: Icarus
subtitle:
description: Hexo theme - Icarus
author: PPOffice
author_title: 'Web Developer & Designer'
avatar: css/images/avatar.png
location: 'Harbin, China'
language: en
timezone:

...

# Disqus
disqus_shortname:
```

- **author** - Your name.
- **author_title** - Title to your occupation.
- **avatar** - Your avatar image link.
- **location** - Where you live in.
- **disqus_shortname** - Your Disqus shortname.

### Post Thumbnail & Banner

You can add a thumbnail and a banner to each post by adding the following lines into your post source files' front-matter:
```r
title: Demo
date: 2015-01-01
...
# add those
thumbnail: http://example.com/thumbnail.jpg
banner: http://example.com/banner.jpg
```

### Custom Categories & Tags Pages

To enable custom categories page and tags page, just copy the `categories` folder and `tags` folder under your theme's `_source` foler into your site's `source` folder. Then edit theme's _config.yml and add the following lines:
```r
# Header
menu:
  ...
  Categories: categories # -> add this line
  Tags: tags # -> and add this line
  ...
```

### Languages

English and Simplified Chinese are the default languages of the theme. You can add translations in the `languages` folder and change the default language in blog's `_config.yml`.

```r
language: zh-CN
```

## Features

### Profile Sidebar

A nice place to show yourself. You can add your own information in your site's `_config.yml`

![](http://ppoffice.github.io/hexo-theme-icarus/gallery/profile.png "")

### Post Banner & Thumbnail

Thanks to [atika](https://github.com/atika), you can now add thumbnails and banners to every post to create better reading experience.

### Responsive Layout

Icarus knows on what screen size you are browsering the website, and reorganize the layout to fit your device.

![](http://ppoffice.github.io/hexo-theme-icarus/gallery/responsive.jpg "")

### Custom Categories & Tags Pages

Get your categories and tags listed in single pages to make your blog more methodic.

### Fancybox

Icarus uses [Fancybox] to showcase your photos. You can use Markdown syntax or fancybox tag plugin to add your photos.

```
![img caption](img url)
```

### Sidebar

Icarus provides 6 built-in widgets:

- recent_posts
- category
- archives
- tag
- tagcloud
- links

All of them are enabled by default. You can edit them in `widget` setting.

## Development

### Requirements

- [Grunt] 0.4+
- Hexo 3.0+

### Grunt tasks

- **default** - Download [Fancybox] and [Font Awesome].
- **fontawesome** - Only download [Font Awesome].
- **fancybox** - Only download [Fancybox].
- **clean** - Clean temporarily files and downloaded files.

[Hexo]: http://zespia.tw/hexo/
[Fancybox]: http://fancyapps.com/fancybox/
[Font Awesome]: http://fontawesome.io/
[Grunt]: http://gruntjs.com/


text:
<!DOCTYPE html>

<meta charset="UTF-8">

<title>module BingAdsApi::ReportAggregation - RDoc Documentation</title>

<link href="../fonts.css" rel="stylesheet">
<link href="../rdoc.css" rel="stylesheet">

    Home

    Pages
    Classes
    Methods

  <form action="#" method="get" accept-charset="utf-8">

      <input id="search-field" role="combobox" aria-label="Search"
             aria-autocomplete="list" aria-controls="search-results"
             type="text" name="search" placeholder="Search" spellcheck="false"
             title="Type to search, Up and Down to navigate, Enter to load">

  </form>

    module BingAdsApi::ReportAggregation

Public : Module for Reporting languages

Example

BingAdsApi::ReportAggregation.SUMMARY
# => 'Summary'
BingAdsApi::ReportAggregation.HOURLY
# => 'Hourly'

Author

jlopezn@neonline.cl

Validate

Generated by RDoc 4.1.1.

Based on Darkfish by Michael Granger.


text:
package com.tianzhu.web.controller;

import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.view.InternalResourceView;

/**
 * Handles requests for the application home page.
 */
@Controller
@RequestMapping(value = "home")
public class HomeController {

	private static final Logger logger = LoggerFactory.getLogger(HomeController.class);

	/**
	 * Simply selects the home view to render by returning its name.
	 */
	@RequestMapping(value = "thymeleaf", method = RequestMethod.GET)
	public String home(Locale locale, Model model) {
		logger.info("Welcome home! The client locale is {}.", locale);
		logger.debug("Welcome home! The client locale is {}.", locale);
		logger.trace("Welcome home! The client locale is {}.", locale);
		logger.warn("Welcome home! The client locale is {}.", locale);
		logger.error("Welcome home! The client locale is {}.", locale);

		Date date = new Date();
		//DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);

		//String formattedDate = dateFormat.format(date);

		model.addAttribute("serverTime", date );

		return "home/home";
	}

	@RequestMapping(value = "jsp", method = RequestMethod.GET)
	public String homejsp(Locale locale, Model model) {
		logger.info("Welcome home! The client locale is {}.", locale);
		logger.debug("Welcome home! The client locale is {}.", locale);
		logger.trace("Welcome home! The client locale is {}.", locale);
		logger.warn("Welcome home! The client locale is {}.", locale);
		logger.error("Welcome home! The client locale is {}.", locale);

		Date date = new Date();
		DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);

		String formattedDate = dateFormat.format(date);

		model.addAttribute("serverTime", formattedDate );
		//ModelAndView modelandview = new ModelAndView(new InternalResourceView("/WEB-INF/jsps/homejsp.jsp"));
		//modelAndView.addObject("serverTime", formattedDate);
		//modelandview.addObject("serverTime", formattedDate);
		return "home/homejsp.jsp";

	}

	@RequestMapping(value = "freemarker", method = RequestMethod.GET)
	public String homefree(Locale locale, Model model) {
		logger.info("Welcome home! The client locale is {}.", locale);
		logger.debug("Welcome home! The client locale is {}.", locale);
		logger.trace("Welcome home! The client locale is {}.", locale);
		logger.warn("Welcome home! The client locale is {}.", locale);
		logger.error("Welcome home! The client locale is {}.", locale);

		Date date = new Date();
		DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);

		String formattedDate = dateFormat.format(date);

		model.addAttribute("serverTime", formattedDate );
		//ModelAndView modelandview = new ModelAndView(new InternalResourceView("/WEB-INF/jsps/homejsp.jsp"));
		//modelAndView.addObject("serverTime", formattedDate);
		//modelandview.addObject("serverTime", formattedDate);
		return "home/homefree.ftl";

	}

}


text:
package chug_test

import (
	"errors"
	"io"
	"time"

	"../..//lager"
	. "../..//lager/chug"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Chug", func() {
	var (
		logger     lager.Logger
		stream     chan Entry
		pipeReader *io.PipeReader
		pipeWriter *io.PipeWriter
	)

	BeforeEach(func() {
		pipeReader, pipeWriter = io.Pipe()
		logger = lager.NewLogger("chug-test")
		logger.RegisterSink(lager.NewWriterSink(pipeWriter, lager.DEBUG))
		stream = make(chan Entry, 100)
		go Chug(pipeReader, stream)
	})

	AfterEach(func() {
		pipeWriter.Close()
		Eventually(stream).Should(BeClosed())
	})

	Context("when fed a stream of well-formed lager messages", func() {
		It("should return parsed lager messages", func() {
			data := lager.Data{"some-float": 3.0, "some-string": "foo"}
			logger.Debug("chug", data)
			logger.Info("again", data)

			entry := <-stream
			Ω(entry.IsLager).Should(BeTrue())
			Ω(entry.Log).Should(MatchLogEntry(LogEntry{
				LogLevel: lager.DEBUG,
				Source:   "chug-test",
				Message:  "chug-test.chug",
				Data:     data,
			}))

			entry = <-stream
			Ω(entry.IsLager).Should(BeTrue())
			Ω(entry.Log).Should(MatchLogEntry(LogEntry{
				LogLevel: lager.INFO,
				Source:   "chug-test",
				Message:  "chug-test.again",
				Data:     data,
			}))
		})

		It("should parse the timestamp", func() {
			logger.Debug("chug")
			entry := <-stream
			Ω(entry.Log.Timestamp).Should(BeTemporally("~", time.Now(), 10*time.Millisecond))
		})

		Context("when parsing an error message", func() {
			It("should include the error", func() {
				data := lager.Data{"some-float": 3.0, "some-string": "foo"}
				logger.Error("chug", errors.New("some-error"), data)
				Ω((<-stream).Log).Should(MatchLogEntry(LogEntry{
					LogLevel: lager.ERROR,
					Source:   "chug-test",
					Message:  "chug-test.chug",
					Error:    errors.New("some-error"),
					Data:     lager.Data{"some-float": 3.0, "some-string": "foo"},
				}))
			})
		})

		Context("when parsing an info message with an error", func() {
			It("should not take the error out of the data map", func() {
				data := lager.Data{"some-float": 3.0, "some-string": "foo", "error": "some-error"}
				logger.Info("chug", data)
				Ω((<-stream).Log).Should(MatchLogEntry(LogEntry{
					LogLevel: lager.INFO,
					Source:   "chug-test",
					Message:  "chug-test.chug",
					Error:    nil,
					Data:     lager.Data{"some-float": 3.0, "some-string": "foo", "error": "some-error"},
				}))
			})
		})

		Context("when multiple sessions have been established", func() {
			It("should build up the task array appropriately", func() {
				firstSession := logger.Session("first-session")
				firstSession.Info("encabulate")
				nestedSession := firstSession.Session("nested-session-1")
				nestedSession.Info("baconize")
				firstSession.Info("remodulate")
				nestedSession.Info("ergonomize")
				nestedSession = firstSession.Session("nested-session-2")
				nestedSession.Info("modernify")

				Ω((<-stream).Log).Should(MatchLogEntry(LogEntry{
					LogLevel: lager.INFO,
					Source:   "chug-test",
					Message:  "chug-test.first-session.encabulate",
					Session:  "1",
					Data:     lager.Data{},
				}))

				Ω((<-stream).Log).Should(MatchLogEntry(LogEntry{
					LogLevel: lager.INFO,
					Source:   "chug-test",
					Message:  "chug-test.first-session.nested-session-1.baconize",
					Session:  "1.1",
					Data:     lager.Data{},
				}))

				Ω((<-stream).Log).Should(MatchLogEntry(LogEntry{
					LogLevel: lager.INFO,
					Source:   "chug-test",
					Message:  "chug-test.first-session.remodulate",
					Session:  "1",
					Data:     lager.Data{},
				}))

				Ω((<-stream).Log).Should(MatchLogEntry(LogEntry{
					LogLevel: lager.INFO,
					Source:   "chug-test",
					Message:  "chug-test.first-session.nested-session-1.ergonomize",
					Session:  "1.1",
					Data:     lager.Data{},
				}))

				Ω((<-stream).Log).Should(MatchLogEntry(LogEntry{
					LogLevel: lager.INFO,
					Source:   "chug-test",
					Message:  "chug-test.first-session.nested-session-2.modernify",
					Session:  "1.2",
					Data:     lager.Data{},
				}))
			})
		})
	})

	Context("handling lager JSON that is surrounded by non-JSON", func() {
		var input []byte
		var entry Entry

		BeforeEach(func() {
			input = []byte(`[some-component][e]{"timestamp":"1407102779.028711081","source":"chug-test","message":"chug-test.chug","log_level":0,"data":{"some-float":3,"some-string":"foo"}}...some trailing stuff`)
			pipeWriter.Write(input)
			pipeWriter.Write([]byte("\n"))

			Eventually(stream).Should(Receive(&entry))
		})

		It("should be a lager message", func() {
			Ω(entry.IsLager).Should(BeTrue())
		})

		It("should contain all the data in Raw", func() {
			Ω(entry.Raw).Should(Equal(input))
		})

		It("should succesfully parse the lager message", func() {
			Ω(entry.Log.Source).Should(Equal("chug-test"))
		})
	})

	Context("handling malformed/non-lager data", func() {
		var input []byte
		var entry Entry

		JustBeforeEach(func() {
			pipeWriter.Write(input)
			pipeWriter.Write([]byte("\n"))

			Eventually(stream).Should(Receive(&entry))
		})

		itReturnsRawData := func() {
			It("returns raw data", func() {
				Ω(entry.IsLager).Should(BeFalse())
				Ω(entry.Log).Should(BeZero())
				Ω(entry.Raw).Should(Equal(input))
			})
		}

		Context("when fed a stream of malformed lager messages", func() {
			Context("when the timestamp is invalid", func() {
				BeforeEach(func() {
					input = []byte(`{"timestamp":"tomorrow","source":"chug-test","message":"chug-test.chug","log_level":3,"data":{"some-float":3,"some-string":"foo","error":7}}`)
				})

				itReturnsRawData()
			})

			Context("when the error does not parse", func() {
				BeforeEach(func() {
					input = []byte(`{"timestamp":"1407102779.028711081","source":"chug-test","message":"chug-test.chug","log_level":3,"data":{"some-float":3,"some-string":"foo","error":7}}`)
				})

				itReturnsRawData()
			})

			Context("when the trace does not parse", func() {
				BeforeEach(func() {
					input = []byte(`{"timestamp":"1407102779.028711081","source":"chug-test","message":"chug-test.chug","log_level":3,"data":{"some-float":3,"some-string":"foo","trace":7}}`)
				})

				itReturnsRawData()
			})

			Context("when the session does not parse", func() {
				BeforeEach(func() {
					input = []byte(`{"timestamp":"1407102779.028711081","source":"chug-test","message":"chug-test.chug","log_level":3,"data":{"some-float":3,"some-string":"foo","session":7}}`)
				})

				itReturnsRawData()
			})
		})

		Context("When fed JSON that is not a lager message at all", func() {
			BeforeEach(func() {
				input = []byte(`{"source":"chattanooga"}`)
			})

			itReturnsRawData()
		})

		Context("When fed none-JSON that is not a lager message at all", func() {
			BeforeEach(func() {
				input = []byte(`ß`)
			})

			itReturnsRawData()
		})
	})
})


text:
#include <string>
#include <stdint.h>

class TestClass {
public:
  TestClass();
  ~TestClass();

  void action1(uint32_t unused_parameter);
  void action2(char *string);
  void action3(const TestClass &tc);

  std::string stringValue() {
    return str;
  }

  uint32_t integerValue() {
    return val;
  }

  uint32_t variable() {
    return m_variable;
  }

  uint32_t setVariable(uint32_t value) {
    m_variable = value;
  }

  enum Test {
    Foo1, Foo2, Foo3, Foo4, Foo6 = 6
  };

  void testEnum(Test param) {
  }

protected:
  uint32_t val;
  std::string str;

  uint32_t m_variable;
};


text:
using Newtonsoft.Json;
using System;
using System.Collections.Generic;

namespace Wargaming.WebAPI.WoT.Model
{
	public class StrongholdInformation
	{
		/// <summary>
		/// End date of Period of Neutrality
		/// </summary>
		[JsonProperty("vacation_finish")]
		private double? VacationEndValue
		{
			get { return this.VacationEnd.ToDouble(); }
			set { this.VacationEnd = value.ToDateTime(); }
		}

		/// <summary>
		/// End date of Period of Neutrality
		/// </summary>
		[JsonIgnore]
		public DateTime? VacationEnd { get; set; } = ConverterExtensions.BaseDate();

		/// <summary>
		/// Start date of Period of Neutrality
		/// </summary>
		[JsonProperty("vacation_start")]
		private double? VacationStartValue
		{
			get { return this.VacationStart.ToDouble(); }
			set { this.VacationStart = value.ToDateTime(); }
		}

		/// <summary>
		/// Start date of Period of Neutrality
		/// </summary>
		[JsonIgnore]
		public DateTime? VacationStart { get; set; } = ConverterExtensions.BaseDate();

		/// <summary>
		/// Total number of battles fought by clan
		/// </summary>
		[JsonProperty("battles_count_total")]
		public int BattlesCount { get; set; }

		/// <summary>
		/// Number of structures
		/// </summary>
		[JsonProperty("buildings_count")]
		public int BuildingsCount { get; set; }

		/// <summary>
		/// Ceasefire day. Indicates the index number of the weekday: 0 - Monday, ..., 6 - Sunday. If the Defense Period is not activated, value is -1.
		/// </summary>
		[JsonProperty("day_off")]
		public int CeasefireDayNo { get; set; }

		/// <summary>
		/// Indicates if the defense period is activated
		/// </summary>
		[JsonProperty("defense_mode_is_activated")]
		public bool DefenseModeActivated { get; set; }

		/// <summary>
		/// Names of Zones available in Stronghold
		/// </summary>
		[JsonProperty("directions")]
		public List<string> Directions { get; set; }

		/// <summary>
		/// Number of Zones
		/// </summary>
		[JsonProperty("directions_count")]
		public int DirectionsCount { get; set; }

		/// <summary>
		/// Tier
		/// </summary>
		[JsonProperty("level")]
		public int Level { get; set; }

		/// <summary>
		/// Server ID
		/// </summary>
		[JsonProperty("server")]
		public string Server { get; set; }

		/// <summary>
		/// Clan ID
		/// </summary>
		[JsonProperty("clan_id")]
		public int ClanId { get; set; }

		/// <summary>
		/// Clan tag
		/// </summary>
		[JsonProperty("tag")]
		public string ClanTag { get; set; }

		/// <summary>
		/// Clan name
		/// </summary>
		[JsonProperty("name")]
		public string ClanName { get; set; }

		/// <summary>
		/// Structures info by unique type IDs
		/// </summary>
		[JsonProperty("buildings")]
		public Dictionary<string, BuildingInformation> Buildings { get; set; }

		/// <summary>
		/// Information on the active Defense Period.
		/// </summary>
		[JsonProperty("defense")]
		public DefenseInformation Defense { get; set; } = new DefenseInformation();

		/// <summary>
		/// Information on Skirmishes
		/// </summary>
		[JsonProperty("skirmish")]
		public SkirmishInformation Skirmish { get; set; }

		/// <summary>
		/// Restricted Stronghold data
		/// </summary>
		[JsonProperty("private")]
		public StrongholdInformationPrivate PrivateData { get; set; }
	}
}


text:
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Embryo | My bits</title>
    <link>http://lpantano.github.io/tag/embryo/</link>
      <atom:link href="http://lpantano.github.io/tag/embryo/index.xml" rel="self" type="application/rss+xml" />
    <description>Embryo</description>
    <generator>Wowchemy (https://wowchemy.com)</generator><language>en-us</language><lastBuildDate>Mon, 01 Dec 2014 00:00:00 +0000</lastBuildDate>
    <image>
      <url>http://lpantano.github.io/images/icon_hu0b7a4cb9992c9ac0e91bd28ffd38dd00_9727_512x512_fill_lanczos_center_3.png</url>
      <title>Embryo</title>
      <link>http://lpantano.github.io/tag/embryo/</link>
    </image>

    <item>
      <title>Paternal Diet Defines Offspring Chromatin State and Intergenerational Obesity</title>
      <link>http://lpantano.github.io/publication/ost-2014/</link>
      <pubDate>Mon, 01 Dec 2014 00:00:00 +0000</pubDate>
      <guid>http://lpantano.github.io/publication/ost-2014/</guid>
      <description></description>
    </item>

  </channel>
</rss>


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Hyaloscypha quercina var. quercina Velen.

### Remarks
null