text:
package org.apache.wicket.util.io;

import java.io.Externalizable;
import java.io.IOException;
import java.io.NotSerializableException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamField;
import java.io.OutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Date;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.Stack;

import org.apache.wicket.Component;
import org.apache.wicket.WicketRuntimeException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Utility class that analyzes objects for non-serializable nodes. Construct, then call
 * {@link #check(Object)} with the object you want to check. When a non-serializable object is
 * found, a {@link WicketNotSerializableException} is thrown with a message that shows the trace up
 * to the not-serializable object. The exception is thrown for the first non-serializable instance
 * it encounters, so multiple problems will not be shown.
 * <p>
 * As this class depends heavily on JDK's serialization internals using introspection, analyzing may
 * not be possible, for instance when the runtime environment does not have sufficient rights to set
 * fields accessible that would otherwise be hidden. You should call
 * {@link SerializableChecker#isAvailable()} to see whether this class can operate properly. If it
 * doesn't, you should fall back to e.g. re-throwing/ printing the {@link NotSerializableException}
 * you probably got before using this class.
 * </p>
 *
 * @author eelcohillenius
 * @author Al Maw
 */
public final class SerializableChecker extends ObjectOutputStream
{

	/** log. */
	private static final Logger log = LoggerFactory.getLogger(SerializableChecker.class);

	/**
	 * Exception that is thrown when a non-serializable object was found.
	 */
	public static final class WicketNotSerializableException extends WicketRuntimeException
	{
		private static final long serialVersionUID = 1L;

		WicketNotSerializableException(String message, Throwable cause)
		{
			super(message, cause);
		}
	}

	/**
	 * Does absolutely nothing.
	 */
	private static class NoopOutputStream extends OutputStream
	{
		@Override
		public void close()
		{
		}

		@Override
		public void flush()
		{
		}

		@Override
		public void write(byte[] b)
		{
		}

		@Override
		public void write(byte[] b, int i, int l)
		{
		}

		@Override
		public void write(int b)
		{
		}
	}

	private static abstract class ObjectOutputAdaptor implements ObjectOutput
	{

		public void close() throws IOException
		{
		}

		public void flush() throws IOException
		{
		}

		public void write(byte[] b) throws IOException
		{
		}

		public void write(byte[] b, int off, int len) throws IOException
		{
		}

		public void write(int b) throws IOException
		{
		}

		public void writeBoolean(boolean v) throws IOException
		{
		}

		public void writeByte(int v) throws IOException
		{
		}

		public void writeBytes(String s) throws IOException
		{
		}

		public void writeChar(int v) throws IOException
		{
		}

		public void writeChars(String s) throws IOException
		{
		}

		public void writeDouble(double v) throws IOException
		{
		}

		public void writeFloat(float v) throws IOException
		{
		}

		public void writeInt(int v) throws IOException
		{
		}

		public void writeLong(long v) throws IOException
		{
		}

		public void writeShort(int v) throws IOException
		{
		}

		public void writeUTF(String str) throws IOException
		{
		}
	}

	/** Holds information about the field and the resulting object being traced. */
	private static final class TraceSlot
	{
		private final String fieldDescription;

		private final Object object;

		TraceSlot(Object object, String fieldDescription)
		{
			super();
			this.object = object;
			this.fieldDescription = fieldDescription;
		}

		@Override
		public String toString()
		{
			return object.getClass() + " - " + fieldDescription;
		}
	}

	private static final NoopOutputStream DUMMY_OUTPUT_STREAM = new NoopOutputStream();

	/** Whether we can execute the tests. If false, check will just return. */
	private static boolean available = true;

	// this hack - accessing the serialization API through introspection - is
	// the only way to use Java serialization for our purposes without writing
	// the whole thing from scratch (and even then, it would be limited). This
	// way of working is of course fragile for internal API changes, but as we
	// do an extra check on availability and we report when we can't use this
	// introspection fu, we'll find out soon enough and clients on this class
	// can fall back on Java's default exception for serialization errors (which
	// sucks and is the main reason for this attempt).
	private static Method LOOKUP_METHOD;

	private static Method GET_CLASS_DATA_LAYOUT_METHOD;

	private static Method GET_NUM_OBJ_FIELDS_METHOD;

	private static Method GET_OBJ_FIELD_VALUES_METHOD;

	private static Method GET_FIELD_METHOD;

	private static Method HAS_WRITE_REPLACE_METHOD_METHOD;

	private static Method INVOKE_WRITE_REPLACE_METHOD;

	static
	{
		try
		{
			LOOKUP_METHOD = ObjectStreamClass.class.getDeclaredMethod("lookup", new Class[] {
					Class.class, Boolean.TYPE });
			LOOKUP_METHOD.setAccessible(true);

			GET_CLASS_DATA_LAYOUT_METHOD = ObjectStreamClass.class.getDeclaredMethod(
				"getClassDataLayout", (Class[])null);
			GET_CLASS_DATA_LAYOUT_METHOD.setAccessible(true);

			GET_NUM_OBJ_FIELDS_METHOD = ObjectStreamClass.class.getDeclaredMethod(
				"getNumObjFields", (Class[])null);
			GET_NUM_OBJ_FIELDS_METHOD.setAccessible(true);

			GET_OBJ_FIELD_VALUES_METHOD = ObjectStreamClass.class.getDeclaredMethod(
				"getObjFieldValues", new Class[] { Object.class, Object[].class });
			GET_OBJ_FIELD_VALUES_METHOD.setAccessible(true);

			GET_FIELD_METHOD = ObjectStreamField.class.getDeclaredMethod("getField", (Class[])null);
			GET_FIELD_METHOD.setAccessible(true);

			HAS_WRITE_REPLACE_METHOD_METHOD = ObjectStreamClass.class.getDeclaredMethod(
				"hasWriteReplaceMethod", (Class[])null);
			HAS_WRITE_REPLACE_METHOD_METHOD.setAccessible(true);

			INVOKE_WRITE_REPLACE_METHOD = ObjectStreamClass.class.getDeclaredMethod(
				"invokeWriteReplace", new Class[] { Object.class });
			INVOKE_WRITE_REPLACE_METHOD.setAccessible(true);
		}
		catch (Exception e)
		{
			log.warn("SerializableChecker not available", e);
			available = false;
		}
	}

	/**
	 * Gets whether we can execute the tests. If false, calling {@link #check(Object)} will just
	 * return and you are advised to rely on the {@link NotSerializableException}. Clients are
	 * advised to call this method prior to calling the check method.
	 *
	 * @return whether security settings and underlying API etc allow for accessing the
	 *         serialization API using introspection
	 */
	public static boolean isAvailable()
	{
		return available;
	}

	/** object stack that with the trace path. */
	private final LinkedList<TraceSlot> traceStack = new LinkedList<TraceSlot>();

	/** set for checking circular references. */
	private final Map<Object, Object> checked = new IdentityHashMap<Object, Object>();

	/** string stack with current names pushed. */
	private final LinkedList<String> nameStack = new LinkedList<String>();

	/** root object being analyzed. */
	private Object root;

	/** set of classes that had no writeObject methods at lookup (to avoid repeated checking) */
	private final Set<Class<?>> writeObjectMethodMissing = new HashSet<Class<?>>();

	/** current simple field name. */
	private String simpleName = "";

	/** current full field description. */
	private String fieldDescription;

	/** Exception that should be set as the cause when throwing a new exception. */
	private final NotSerializableException exception;

	private final Stack<Object> stack = new Stack<Object>();

	/**
	 * Construct.
	 *
	 * @param exception
	 *            exception that should be set as the cause when throwing a new exception
	 *
	 * @throws IOException
	 */
	public SerializableChecker(NotSerializableException exception) throws IOException
	{
		this.exception = exception;
	}

	/**
	 * @see java.io.ObjectOutputStream#reset()
	 */
	@Override
	public void reset() throws IOException
	{
		root = null;
		checked.clear();
		fieldDescription = null;
		simpleName = null;
		traceStack.clear();
		nameStack.clear();
		writeObjectMethodMissing.clear();
	}

	private void check(Object obj)
	{
		if (obj == null)
		{
			return;
		}

		try
		{
			if (stack.contains(obj))
			{
				return;
			}
		}
		catch (RuntimeException e)
		{
			log.warn("Wasn't possible to check the object " + obj.getClass() +
				" possible due an problematic implementation of equals method");
			/*
			 * Can't check if this obj were in stack, giving up because we don't want to throw an
			 * invaluable exception to user. The main goal of this checker is to find non
			 * serializable data
			 */
			return;
		}

		stack.push(obj);
		try
		{
			internalCheck(obj);
		}
		finally
		{
			stack.pop();
		}
	}

	private void internalCheck(Object obj)
	{
		if (obj == null)
		{
			return;
		}

		Class<?> cls = obj.getClass();
		nameStack.add(simpleName);
		traceStack.add(new TraceSlot(obj, fieldDescription));

		if (!(obj instanceof Serializable) && (!Proxy.isProxyClass(cls)))
		{
			throw new WicketNotSerializableException(
				toPrettyPrintedStack(obj.getClass().getName()), exception);
		}

		ObjectStreamClass desc;
		for (;;)
		{
			try
			{
				desc = (ObjectStreamClass)LOOKUP_METHOD.invoke(null, cls, Boolean.TRUE);
				Class<?> repCl;
				if (!(Boolean)HAS_WRITE_REPLACE_METHOD_METHOD.invoke(desc, (Object[])null) ||
					(obj = INVOKE_WRITE_REPLACE_METHOD.invoke(desc, obj)) == null ||
					(repCl = obj.getClass()) == cls)
				{
					break;
				}
				cls = repCl;
			}
			catch (IllegalAccessException e)
			{
				throw new RuntimeException(e);
			}
			catch (InvocationTargetException e)
			{
				throw new RuntimeException(e);
			}
		}

		if (cls.isPrimitive())
		{
			// skip
		}
		else if (cls.isArray())
		{
			checked.put(obj, null);
			Class<?> ccl = cls.getComponentType();
			if (!(ccl.isPrimitive()))
			{
				Object[] objs = (Object[])obj;
				for (int i = 0; i < objs.length; i++)
				{
					String arrayPos = "[" + i + "]";
					simpleName = arrayPos;
					fieldDescription += arrayPos;
					check(objs[i]);
				}
			}
		}
		else if (obj instanceof Externalizable && (!Proxy.isProxyClass(cls)))
		{
			Externalizable extObj = (Externalizable)obj;
			try
			{
				extObj.writeExternal(new ObjectOutputAdaptor()
				{
					private int count = 0;

					public void writeObject(Object streamObj) throws IOException
					{
						// Check for circular reference.
						if (checked.containsKey(streamObj))
						{
							return;
						}

						checked.put(streamObj, null);
						String arrayPos = "[write:" + count++ + "]";
						simpleName = arrayPos;
						fieldDescription += arrayPos;

						check(streamObj);
					}
				});
			}
			catch (Exception e)
			{
				if (e instanceof WicketNotSerializableException)
				{
					throw (WicketNotSerializableException)e;
				}
				log.warn("error delegating to Externalizable : " + e.getMessage() + ", path: " +
					currentPath());
			}
		}
		else
		{
			Method writeObjectMethod = null;
			if (writeObjectMethodMissing.contains(cls) == false)
			{
				try
				{
					writeObjectMethod = cls.getDeclaredMethod("writeObject",
						new Class[] { java.io.ObjectOutputStream.class });
				}
				catch (SecurityException e)
				{
					// we can't access / set accessible to true
					writeObjectMethodMissing.add(cls);
				}
				catch (NoSuchMethodException e)
				{
					// cls doesn't have that method
					writeObjectMethodMissing.add(cls);
				}
			}

			final Object original = obj;
			if (writeObjectMethod != null)
			{
				class InterceptingObjectOutputStream extends ObjectOutputStream
				{
					private int counter;

					InterceptingObjectOutputStream() throws IOException
					{
						super(DUMMY_OUTPUT_STREAM);
						enableReplaceObject(true);
					}

					@Override
					protected Object replaceObject(Object streamObj) throws IOException
					{
						if (streamObj == original)
						{
							return streamObj;
						}

						counter++;
						// Check for circular reference.
						if (checked.containsKey(streamObj))
						{
							return null;
						}

						checked.put(streamObj, null);
						String arrayPos = "[write:" + counter + "]";
						simpleName = arrayPos;
						fieldDescription += arrayPos;
						check(streamObj);
						return streamObj;
					}
				}
				try
				{
					InterceptingObjectOutputStream ioos = new InterceptingObjectOutputStream();
					ioos.writeObject(obj);
				}
				catch (Exception e)
				{
					if (e instanceof WicketNotSerializableException)
					{
						throw (WicketNotSerializableException)e;
					}
					log.warn("error delegating to writeObject : " + e.getMessage() + ", path: " +
						currentPath());
				}
			}
			else
			{
				Object[] slots;
				try
				{
					slots = (Object[])GET_CLASS_DATA_LAYOUT_METHOD.invoke(desc, (Object[])null);
				}
				catch (Exception e)
				{
					throw new RuntimeException(e);
				}
				for (Object slot : slots)
				{
					ObjectStreamClass slotDesc;
					try
					{
						Field descField = slot.getClass().getDeclaredField("desc");
						descField.setAccessible(true);
						slotDesc = (ObjectStreamClass)descField.get(slot);
					}
					catch (Exception e)
					{
						throw new RuntimeException(e);
					}
					checked.put(obj, null);
					checkFields(obj, slotDesc);
				}
			}
		}

		traceStack.removeLast();
		nameStack.removeLast();
	}

	private void checkFields(Object obj, ObjectStreamClass desc)
	{
		int numFields;
		try
		{
			numFields = (Integer)GET_NUM_OBJ_FIELDS_METHOD.invoke(desc, (Object[])null);
		}
		catch (IllegalAccessException e)
		{
			throw new RuntimeException(e);
		}
		catch (InvocationTargetException e)
		{
			throw new RuntimeException(e);
		}

		if (numFields > 0)
		{
			int numPrimFields;
			ObjectStreamField[] fields = desc.getFields();
			Object[] objVals = new Object[numFields];
			numPrimFields = fields.length - objVals.length;
			try
			{
				GET_OBJ_FIELD_VALUES_METHOD.invoke(desc, obj, objVals);
			}
			catch (IllegalAccessException e)
			{
				throw new RuntimeException(e);
			}
			catch (InvocationTargetException e)
			{
				throw new RuntimeException(e);
			}
			for (int i = 0; i < objVals.length; i++)
			{
				if (objVals[i] instanceof String || objVals[i] instanceof Number ||
					objVals[i] instanceof Date || objVals[i] instanceof Boolean ||
					objVals[i] instanceof Class)
				{
					// filter out common cases
					continue;
				}

				// Check for circular reference.
				if (checked.containsKey(objVals[i]))
				{
					continue;
				}

				ObjectStreamField fieldDesc = fields[numPrimFields + i];
				Field field;
				try
				{
					field = (Field)GET_FIELD_METHOD.invoke(fieldDesc, (Object[])null);
				}
				catch (IllegalAccessException e)
				{
					throw new RuntimeException(e);
				}
				catch (InvocationTargetException e)
				{
					throw new RuntimeException(e);
				}

				field.getName();
				simpleName = field.getName();
				fieldDescription = field.toString();
				check(objVals[i]);
			}
		}
	}

	/**
	 * @return name from root to current node concatenated with slashes
	 */
	private StringBuilder currentPath()
	{
		StringBuilder b = new StringBuilder();
		for (Iterator<String> it = nameStack.iterator(); it.hasNext();)
		{
			b.append(it.next());
			if (it.hasNext())
			{
				b.append('/');
			}
		}
		return b;
	}

	/**
	 * Dump with indentation.
	 *
	 * @param type
	 *            the type that couldn't be serialized
	 * @return A very pretty dump
	 */
	private final String toPrettyPrintedStack(String type)
	{
		StringBuilder result = new StringBuilder();
		StringBuilder spaces = new StringBuilder();
		result.append("Unable to serialize class: ");
		result.append(type);
		result.append("\nField hierarchy is:");
		for (Iterator<TraceSlot> i = traceStack.listIterator(); i.hasNext();)
		{
			spaces.append("  ");
			TraceSlot slot = i.next();
			result.append("\n").append(spaces).append(slot.fieldDescription);
			result.append(" [class=").append(slot.object.getClass().getName());
			if (slot.object instanceof Component)
			{
				Component component = (Component)slot.object;
				result.append(", path=").append(component.getPath());
			}
			result.append("]");
		}
		result.append(" <----- field that is not serializable");
		return result.toString();
	}

	/**
	 * @see java.io.ObjectOutputStream#writeObjectOverride(java.lang.Object)
	 */
	@Override
	protected final void writeObjectOverride(Object obj) throws IOException
	{
		if (!available)
		{
			return;
		}
		root = obj;
		if (fieldDescription == null)
		{
			fieldDescription = (root instanceof Component) ? ((Component)root).getPath() : "";
		}

		check(root);
	}
}


text:
/* Writes players to a specified Firebase Real Time Database
 * Data integrity must be ensured before running this script
*/

var firebase = require('./connect');

// To run the task
// node write-players-to-database --<club-name> --<season>
// <club-name> must match reference in /data/players/source/player-sources.json file
// <season> must match child of <club-name> references in path /data/players/source/player-sources.json file
// <current> is a boolean indicating whether we are collecting for the current season or not

// club is null until specified
// season is null until specified
// current is null until specified
// sources points to a JSON file containing club handles and data endpoints
let club = null;
let season = null;
const sources = require('../data/players/source/player-sources.json');

// Loop through supplied arguments to deduce the club
process.argv.forEach(function(val, index, array) {
    if (index === 2) {
        club = val;
    }
    if (index === 3) {
        season = val
    }
    if (index === 4) {
        current = val
    }
});

if(!club || !season || !sources[club]) {
    console.log('Bad club or season supplied');
    return;
}

var team = sources[club][season];

var players = require('../data/' + team.output.players);

// Get all players from this team from the database
firebase.database().ref('/clubs/scotland/squads/' + club + '/' + season).once('value').then(function(snapshot) {
    const playersInDatabase = snapshot.val();

    // For each player in the players array
    players.forEach(function (player, index) {

        var playerHandle = player.surname + player.firstName + player.birthDate;

        if (playersInDatabase && playersInDatabase[playerHandle]) {
            // Update instead, but return false for now
            firebase.database().ref('/clubs/' + club + '/' + season + '/' + playerHandle).update(player, function (error) {
                if (error) {
                    console.warn('Error updating data for player: ' + player.firstName + ' ' + player.surname);
                    console.warn(error);
                } else {
                    console.log('Successful update for player: ' + player.firstName + ' ' + player.surname);
                }
            });
            return false;
        }

        firebase.database().ref('/clubs/scotland/squads/' + club + '/' + season + '/' + playerHandle).set(player, function (error) {
            if (error) {
                console.warn('Error writing data for player: ' + player.firstName + ' ' + player.surname);
                console.warn(error);
            } else {
                console.log('Successful write for player: ' + player.firstName + ' ' + player.surname);
            }

            // If this is the last player, exit process
            if (index + 1 === players.length) {
                process.exit();
            }
        });
    });
});

redpajama_set_name: RedPajamaGithub


text:
using System;
using MudDesigner.Engine.Game;

namespace MudDesigner.Adapters.BasicRules
{
    public class MudGender : IGender
    {
        /// <summary>
        /// Gets the date that this component was instanced.
        /// </summary>
        public DateTime CreationDate { get; private set; }

        /// <summary>
        /// Gets or sets a description of the object.
        /// </summary>
        public string Description { get; set;}

        /// <summary>
        /// Gets the unique identifier for this component.
        /// </summary>
        public Guid Id { get; private set; }

        /// <summary>
        /// Gets a value indicating whether this instance is enabled.
        /// </summary>
        public bool IsEnabled { get; private set; }

        /// <summary>
        /// Gets the name of the object.
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        /// Gets the amount number of seconds that this component instance has been alive.
        /// </summary>
        public double TimeAlive => this.CreationDate.Subtract(DateTime.Now).TotalSeconds;

        /// <summary>
        /// Disables this instance.
        /// </summary>
        public void Disable()
        {
            this.IsEnabled = false;
        }

        /// <summary>
        /// Enables this instance.
        /// </summary>
        public void Enable()
        {
            this.IsEnabled = true;
        }

        /// <summary>
        /// Sets the name for the gender.
        /// </summary>
        /// <param name="name">The name.</param>
        public void SetName(string name)
        {
            if (string.IsNullOrEmpty(Name))
            {
                throw new InvalidOperationException("You can not provide an empty or null name.");
            }

            this.Name = name;
        }
    }
}


text:
let path = require("path");
let fs = require("../FileSystem/FileSystem");
let File = new fs;

class Compiler {

    constructor(unite) {
        this.unite = unite;
        this.setup = this.getSetup();
    }

    run(suites) {
        return suites.map(suite => this.compile(suite));
    }

    compile(suite) {
        Unite.$events.scope("CompilingEachSuite", (events) => {
            suite.driver.build(this.setup);
            suite.events = events;
            suite.compile();
        });

        return suite;
    }

    getSetup() {
        let setup = "";
        this.unite.$config("setup").forEach(file => {
            let $file = File.get(file);
            setup += $file.content;
        });

        return setup;
    }

}

module.exports = Compiler;


text:
require File.expand_path("../../path.rb", __FILE__)
include Spec::Path

$LOAD_PATH.unshift Dir[base_system_gems.join("gems/artifice*/lib")].first.to_s
$LOAD_PATH.unshift(*Dir[base_system_gems.join("gems/rack-*/lib")])
$LOAD_PATH.unshift Dir[base_system_gems.join("gems/tilt*/lib")].first.to_s
$LOAD_PATH.unshift Dir[base_system_gems.join("gems/sinatra*/lib")].first.to_s
require "artifice"
require "sinatra/base"

Artifice.deactivate

class Windows < Sinatra::Base
  set :raise_errors, true
  set :show_exceptions, false

  helpers do
    def gem_repo
      Pathname.new(ENV["BUNDLER_SPEC_GEM_REPO"] || Spec::Path.gem_repo1)
    end
  end

  files = ["specs.4.8.gz",
           "prerelease_specs.4.8.gz",
           "quick/Marshal.4.8/rcov-1.0-mswin32.gemspec.rz",
           "gems/rcov-1.0-mswin32.gem"]

  files.each do |file|
    get "/#{file}" do
      File.read gem_repo.join(file)
    end
  end

  get "/gems/rcov-1.0-x86-mswin32.gem" do
    halt 404
  end

  get "/api/v1/dependencies" do
    halt 404
  end

  get "/versions" do
    halt 500
  end
end

Artifice.activate_with(Windows)


text:
package de.kisi.android.vicinity.actor;

import android.content.Intent;
import de.kisi.android.KisiApplication;
import de.kisi.android.model.Locator;
import de.kisi.android.ui.KisiMainActivity;
import de.kisi.android.vicinity.LockInVicinityActorInterface;

public class NFCHighlightLockActor implements LockInVicinityActorInterface {

	@Override
	public void actOnEntry(Locator locator) {
		Intent intent = new Intent(KisiApplication.getInstance(), KisiMainActivity.class);
		intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
		intent.putExtra("Type", "highlight");
		intent.putExtra("Sender", "NFC");
		intent.putExtra("Place", locator.getPlaceId());
		intent.putExtra("Lock", locator.getLockId());
		KisiApplication.getInstance().startActivity(intent);
	}

	@Override
	public void actOnExit(Locator locator) {
	}

}


text:
package org.kie.server.api.model;

public enum KieContainerStatus {
    CREATING, STARTED, FAILED, DISPOSING
}


text:
#ifndef VICE_UISID_H
#define VICE_UISID_H

void ui_sid_settings_dialog(HWND hwnd, const int *stereo_baseaddress);

#endif


text:
namespace blink {

class XRInputSourceArray : public ScriptWrappable {
  DEFINE_WRAPPERTYPEINFO();

 public:
  unsigned length() const { return input_sources_.size(); }
  XRInputSource* AnonymousIndexedGetter(unsigned index) const;

  XRInputSource* operator[](unsigned index) const;

  XRInputSource* GetWithSourceId(uint32_t source_id);
  void RemoveWithSourceId(uint32_t source_id);
  void SetWithSourceId(uint32_t source_id, XRInputSource* input_source);

  void Trace(Visitor*) const override;

 private:
  HeapHashMap<uint32_t, Member<XRInputSource>> input_sources_;
};

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_XR_XR_INPUT_SOURCE_ARRAY_H_


text:
require 'spec_helper'

describe Refinery::Videos::Admin::VideoFilesController, type: :controller do
  let(:logged_in_user) { Refinery::Core::NilUser.new }

  describe 'delete video file' do
    let!(:video_file) {FactoryGirl.create(:video_file, external_url: 'url', use_external: true)}
    let!(:video) {FactoryGirl.build(:video, use_shared: false)}

    before (:each) do
      video.video_files << video_file
      video.save!
    end

    it 'deletes the video_file' do
      post :destroy, id: video_file.id
      expect(::Refinery::Videos::VideoFile.count).to eq(0)
    end

    it 'redirects to the video previously associated with the file' do
      post :destroy, id: video_file.id
      expect(response.status).to eq(302)
      expect(response).to be_redirect
      expect(response).to redirect_to "/refinery/videos/#{video.id}/edit"
    end

  end

end


text:
// Copyright (c) Microsoft Corporation.  All rights reserved.
// Licensed under the MIT License.  See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Web.Http;
using System.Web.OData.Properties;

namespace System.Web.OData.Builder
{
    /// <summary>
    /// Represents a navigation source
    /// </summary>
    public interface INavigationSourceConfiguration
    {
        /// <summary>
        /// Gets the navigation targets of <see cref=" NavigationSourceConfiguration"/>.
        /// </summary>
        IEnumerable<NavigationPropertyBindingConfiguration> Bindings { get; }

        /// <summary>
        /// Gets the entity type contained in this navigation source.
        /// </summary>
        EntityTypeConfiguration EntityType { get; }

        /// <summary>
        /// Gets the backing <see cref="Type"/> for the entity type contained in this navigation source.
        /// </summary>
        Type ClrType { get; }

        /// <summary>
        /// Gets the name of this navigation source.
        /// </summary>
        string Name { get; }

        /// <summary>
        /// Configures the navigation source URL.
        /// </summary>
        /// <param name="url">The navigation source URL.</param>
        /// <returns>Returns itself so that multiple calls can be chained.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings",
            MessageId = "0#", Justification = "This Url property is not required to be a valid Uri")]
        INavigationSourceConfiguration HasUrl(string url);

        /// <summary>
        /// Configures the edit link for this navigation source.
        /// </summary>
        /// <param name="editLinkBuilder">The builder used to generate the edit link.</param>
        /// <returns>Returns itself so that multiple calls can be chained.</returns>
        INavigationSourceConfiguration HasEditLink(SelfLinkBuilder<Uri> editLinkBuilder);

        /// <summary>
        /// Configures the read link for this navigation source.
        /// </summary>
        /// <param name="readLinkBuilder">The builder used to generate the read link.</param>
        /// <returns>Returns itself so that multiple calls can be chained.</returns>
        INavigationSourceConfiguration HasReadLink(SelfLinkBuilder<Uri> readLinkBuilder);

        /// <summary>
        /// Configures the ID link for this navigation source.
        /// </summary>
        /// <param name="idLinkBuilder">The builder used to generate the ID.</param>
        /// <returns>Returns itself so that multiple calls can be chained.</returns>
        INavigationSourceConfiguration HasIdLink(SelfLinkBuilder<Uri> idLinkBuilder);

        /// <summary>
        /// Configures the navigation link for the given navigation property for this navigation source.
        /// </summary>
        /// <param name="navigationProperty">The navigation property for which the navigation link is being generated.</param>
        /// <param name="navigationLinkBuilder">The builder used to generate the navigation link.</param>
        /// <returns>Returns itself so that multiple calls can be chained.</returns>
        INavigationSourceConfiguration HasNavigationPropertyLink(NavigationPropertyConfiguration navigationProperty,
            NavigationLinkBuilder navigationLinkBuilder);

        /// <summary>
        /// Configures the navigation link for the given navigation properties for this navigation source.
        /// </summary>
        /// <param name="navigationProperties">The navigation properties for which the navigation link is being generated.</param>
        /// <param name="navigationLinkBuilder">The builder used to generate the navigation link.</param>
        /// <returns>Returns itself so that multiple calls can be chained.</returns>
        INavigationSourceConfiguration HasNavigationPropertiesLink(
            IEnumerable<NavigationPropertyConfiguration> navigationProperties, NavigationLinkBuilder navigationLinkBuilder);

        /// <summary>
        /// Binds the given navigation property to the target navigation source.
        /// </summary>
        /// <param name="navigationConfiguration">The navigation property.</param>
        /// <param name="targetNavigationSource">The target navigation source.</param>
        /// <returns>The <see cref="NavigationPropertyBindingConfiguration"/> so that it can be further configured.</returns>
        NavigationPropertyBindingConfiguration AddBinding(NavigationPropertyConfiguration navigationConfiguration,
            INavigationSourceConfiguration targetNavigationSource);

        /// <summary>
        /// Removes the binding for the given navigation property.
        /// </summary>
        /// <param name="navigationConfiguration">The navigation property</param>
        void RemoveBinding(NavigationPropertyConfiguration navigationConfiguration);

        /// <summary>
        /// Finds the binding for the given navigation property and tries to create it if it doesnot exist.
        /// </summary>
        /// <param name="navigationConfiguration">The navigation property.</param>
        /// <returns>The <see cref="NavigationPropertyBindingConfiguration"/> so that it can be further configured.</returns>
        NavigationPropertyBindingConfiguration FindBinding(NavigationPropertyConfiguration navigationConfiguration);

        /// <summary>
        /// Finds the binding for the given navigation property.
        /// </summary>
        /// <param name="navigationConfiguration">The navigation property.</param>
        /// <param name="autoCreate">Tells whether the binding should be auto created if it does not exist.</param>
        /// <returns>The <see cref="NavigationPropertyBindingConfiguration"/> so that it can be further configured.</returns>
        NavigationPropertyBindingConfiguration FindBinding(NavigationPropertyConfiguration navigationConfiguration,
            bool autoCreate);

        /// <summary>
        /// Gets the navigation source URL.
        /// </summary>
        /// <returns>The navigation source URL.</returns>
        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "This Url property is not required to be a valid Uri")]
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
            Justification = "Consistent with EF Has/Get pattern")]
        string GetUrl();

        /// <summary>
        /// Gets the builder used to generate edit links for this navigation source.
        /// </summary>
        /// <returns>The link builder.</returns>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
            Justification = "Consistent with EF Has/Get pattern")]
        SelfLinkBuilder<Uri> GetEditLink();

        /// <summary>
        /// Gets the builder used to generate read links for this navigation source.
        /// </summary>
        /// <returns>The link builder.</returns>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
            Justification = "Consistent with EF Has/Get pattern")]
        SelfLinkBuilder<Uri> GetReadLink();

        /// <summary>
        /// Gets the builder used to generate ID for this navigation source.
        /// </summary>
        /// <returns>The builder.</returns>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
            Justification = "Consistent with EF Has/Get pattern")]
        SelfLinkBuilder<Uri> GetIdLink();

        /// <summary>
        /// Gets the builder used to generate navigation link for the given navigation property for this navigation source.
        /// </summary>
        /// <param name="navigationProperty">The navigation property.</param>
        /// <returns>The link builder.</returns>
        NavigationLinkBuilder GetNavigationPropertyLink(NavigationPropertyConfiguration navigationProperty);

        /// <summary>
        /// Gets the <see cref="NavigationPropertyBindingConfiguration"/> for the navigation property with the given name.
        /// </summary>
        /// <param name="propertyName">The name of the navigation property.</param>
        /// <returns>The <see cref="NavigationPropertyBindingConfiguration" />.</returns>
        NavigationPropertyBindingConfiguration FindBinding(string propertyName);
    }
}


text:
#ifndef FLUXMAKE_TESTRUNSTAGE_H
#define FLUXMAKE_TESTRUNSTAGE_H

#include "BuildStage.h"

namespace fluxmake {

class TestRunStage: public BuildStage
{
public:
    TestRunStage(BuildPlan *plan);

    inline int testTotal() const { return testTotal_; }
    inline int testFailed() const { return testFailed_; }

    bool run();

private:
    bool runTests(bool report);
    int testTotal_, testFailed_;
};

} // namespace fluxmake

#endif // FLUXMAKE_TESTRUNSTAGE_H


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

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.9"/>
<title>Fat-Free Framework: Bcrypt Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

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

Fat-Free Framework
    3.4.0
    Overview Class List Hierarchy

Public Member Functions |
Public Attributes |
List of all members

Bcrypt Class Reference

Lightweight password hashing library.
 More...

   Inheritance diagram for Bcrypt:

  <map id="Bcrypt_map" name="Bcrypt_map">
<area href="classPrefab.html" title="Factory class for single-instance objects. " alt="Prefab" shape="rect" coords="0,0,50,24"/>
</map>

Public Member Functions

 	hash ($pw, $salt=NULL, $cost=self::COST)

 	needs_rehash ($hash, $cost=self::COST)

 	verify ($pw, $hash)

Public Attributes

const 	COST =10

 	Default cost.

const 	E_CostArg ='Invalid cost parameter'

const 	E_SaltArg ='Salt must be at least 22 alphanumeric characters'

Additional Inherited Members

 Static Public Member Functions inherited from Prefab

static 	instance ()

Detailed Description

Lightweight password hashing library.

Member Function Documentation

          Bcrypt::hash
          (

          $pw,

          $salt = NULL,

          $cost = self::COST

          )

Generate bcrypt hash of string

Returns

string|FALSE

Parameters

$pw	string

$salt	string

$cost	int

          Bcrypt::needs_rehash
          (

          $hash,

          $cost = self::COST

          )

Check if password is still strong enough

Returns

bool

Parameters

$hash	string

$cost	int

          Bcrypt::verify
          (

          $pw,

          $hash

          )

Verify password against hash using timing attack resistant approach

Returns

bool

Parameters

$pw	string

$hash	string

The documentation for this class was generated from the following file:

bcrypt.php


text:
/* dso_dl.c -*- mode:C; c-file-style: "eay" -*- */
/*
 * Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
 * 2000.
 */
/* ====================================================================
 * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <stdio.h>
#include "cryptlib.h"
#include <openssl/dso.h>

#ifndef DSO_DL
DSO_METHOD *DSO_METHOD_dl(void)
{
    return NULL;
}
#else

# include <dl.h>

/* Part of the hack in "dl_load" ... */
# define DSO_MAX_TRANSLATED_SIZE 256

static int dl_load(DSO *dso);
static int dl_unload(DSO *dso);
static void *dl_bind_var(DSO *dso, const char *symname);
static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname);
# if 0
static int dl_unbind_var(DSO *dso, char *symname, void *symptr);
static int dl_unbind_func(DSO *dso, char *symname, DSO_FUNC_TYPE symptr);
static int dl_init(DSO *dso);
static int dl_finish(DSO *dso);
static int dl_ctrl(DSO *dso, int cmd, long larg, void *parg);
# endif
static char *dl_name_converter(DSO *dso, const char *filename);
static char *dl_merger(DSO *dso, const char *filespec1,
                       const char *filespec2);
static int dl_pathbyaddr(void *addr, char *path, int sz);
static void *dl_globallookup(const char *name);

static DSO_METHOD dso_meth_dl = {
    "OpenSSL 'dl' shared library method",
    dl_load,
    dl_unload,
    dl_bind_var,
    dl_bind_func,
/* For now, "unbind" doesn't exist */
# if 0
    NULL,                       /* unbind_var */
    NULL,                       /* unbind_func */
# endif
    NULL,                       /* ctrl */
    dl_name_converter,
    dl_merger,
    NULL,                       /* init */
    NULL,                       /* finish */
    dl_pathbyaddr,
    dl_globallookup
};

DSO_METHOD *DSO_METHOD_dl(void)
{
    return (&dso_meth_dl);
}

/*
 * For this DSO_METHOD, our meth_data STACK will contain; (i) the handle
 * (shl_t) returned from shl_load(). NB: I checked on HPUX11 and shl_t is
 * itself a pointer type so the cast is safe.
 */

static int dl_load(DSO *dso)
{
    shl_t ptr = NULL;
    /*
     * We don't do any fancy retries or anything, just take the method's (or
     * DSO's if it has the callback set) best translation of the
     * platform-independant filename and try once with that.
     */
    char *filename = DSO_convert_filename(dso, NULL);

    if (filename == NULL) {
        DSOerr(DSO_F_DL_LOAD, DSO_R_NO_FILENAME);
        goto err;
    }
    ptr = shl_load(filename, BIND_IMMEDIATE |
                   (dso->flags & DSO_FLAG_NO_NAME_TRANSLATION ? 0 :
                    DYNAMIC_PATH), 0L);
    if (ptr == NULL) {
        DSOerr(DSO_F_DL_LOAD, DSO_R_LOAD_FAILED);
        ERR_add_error_data(4, "filename(", filename, "): ", strerror(errno));
        goto err;
    }
    if (!sk_push(dso->meth_data, (char *)ptr)) {
        DSOerr(DSO_F_DL_LOAD, DSO_R_STACK_ERROR);
        goto err;
    }
    /*
     * Success, stick the converted filename we've loaded under into the DSO
     * (it also serves as the indicator that we are currently loaded).
     */
    dso->loaded_filename = filename;
    return (1);
 err:
    /* Cleanup! */
    if (filename != NULL)
        OPENSSL_free(filename);
    if (ptr != NULL)
        shl_unload(ptr);
    return (0);
}

static int dl_unload(DSO *dso)
{
    shl_t ptr;
    if (dso == NULL) {
        DSOerr(DSO_F_DL_UNLOAD, ERR_R_PASSED_NULL_PARAMETER);
        return (0);
    }
    if (sk_num(dso->meth_data) < 1)
        return (1);
    /* Is this statement legal? */
    ptr = (shl_t) sk_pop(dso->meth_data);
    if (ptr == NULL) {
        DSOerr(DSO_F_DL_UNLOAD, DSO_R_NULL_HANDLE);
        /*
         * Should push the value back onto the stack in case of a retry.
         */
        sk_push(dso->meth_data, (char *)ptr);
        return (0);
    }
    shl_unload(ptr);
    return (1);
}

static void *dl_bind_var(DSO *dso, const char *symname)
{
    shl_t ptr;
    void *sym;

    if ((dso == NULL) || (symname == NULL)) {
        DSOerr(DSO_F_DL_BIND_VAR, ERR_R_PASSED_NULL_PARAMETER);
        return (NULL);
    }
    if (sk_num(dso->meth_data) < 1) {
        DSOerr(DSO_F_DL_BIND_VAR, DSO_R_STACK_ERROR);
        return (NULL);
    }
    ptr = (shl_t) sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
    if (ptr == NULL) {
        DSOerr(DSO_F_DL_BIND_VAR, DSO_R_NULL_HANDLE);
        return (NULL);
    }
    if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0) {
        DSOerr(DSO_F_DL_BIND_VAR, DSO_R_SYM_FAILURE);
        ERR_add_error_data(4, "symname(", symname, "): ", strerror(errno));
        return (NULL);
    }
    return (sym);
}

static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname)
{
    shl_t ptr;
    void *sym;

    if ((dso == NULL) || (symname == NULL)) {
        DSOerr(DSO_F_DL_BIND_FUNC, ERR_R_PASSED_NULL_PARAMETER);
        return (NULL);
    }
    if (sk_num(dso->meth_data) < 1) {
        DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_STACK_ERROR);
        return (NULL);
    }
    ptr = (shl_t) sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
    if (ptr == NULL) {
        DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_NULL_HANDLE);
        return (NULL);
    }
    if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0) {
        DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_SYM_FAILURE);
        ERR_add_error_data(4, "symname(", symname, "): ", strerror(errno));
        return (NULL);
    }
    return ((DSO_FUNC_TYPE)sym);
}

static char *dl_merger(DSO *dso, const char *filespec1, const char *filespec2)
{
    char *merged;

    if (!filespec1 && !filespec2) {
        DSOerr(DSO_F_DL_MERGER, ERR_R_PASSED_NULL_PARAMETER);
        return (NULL);
    }
    /*
     * If the first file specification is a rooted path, it rules. same goes
     * if the second file specification is missing.
     */
    if (!filespec2 || filespec1[0] == '/') {
        merged = OPENSSL_malloc(strlen(filespec1) + 1);
        if (!merged) {
            DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
            return (NULL);
        }
        strcpy(merged, filespec1);
    }
    /*
     * If the first file specification is missing, the second one rules.
     */
    else if (!filespec1) {
        merged = OPENSSL_malloc(strlen(filespec2) + 1);
        if (!merged) {
            DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
            return (NULL);
        }
        strcpy(merged, filespec2);
    } else
        /*
         * This part isn't as trivial as it looks.  It assumes that the
         * second file specification really is a directory, and makes no
         * checks whatsoever.  Therefore, the result becomes the
         * concatenation of filespec2 followed by a slash followed by
         * filespec1.
         */
    {
        int spec2len, len;

        spec2len = (filespec2 ? strlen(filespec2) : 0);
        len = spec2len + (filespec1 ? strlen(filespec1) : 0);

        if (filespec2 && filespec2[spec2len - 1] == '/') {
            spec2len--;
            len--;
        }
        merged = OPENSSL_malloc(len + 2);
        if (!merged) {
            DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
            return (NULL);
        }
        strcpy(merged, filespec2);
        merged[spec2len] = '/';
        strcpy(&merged[spec2len + 1], filespec1);
    }
    return (merged);
}

/*
 * This function is identical to the one in dso_dlfcn.c, but as it is highly
 * unlikely that both the "dl" *and* "dlfcn" variants are being compiled at
 * the same time, there's no great duplicating the code. Figuring out an
 * elegant way to share one copy of the code would be more difficult and
 * would not leave the implementations independant.
 */
# if defined(__hpux)
static const char extension[] = ".sl";
# else
static const char extension[] = ".so";
# endif
static char *dl_name_converter(DSO *dso, const char *filename)
{
    char *translated;
    int len, rsize, transform;

    len = strlen(filename);
    rsize = len + 1;
    transform = (strstr(filename, "/") == NULL);
    {
        /* We will convert this to "%s.s?" or "lib%s.s?" */
        rsize += strlen(extension); /* The length of ".s?" */
        if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
            rsize += 3;         /* The length of "lib" */
    }
    translated = OPENSSL_malloc(rsize);
    if (translated == NULL) {
        DSOerr(DSO_F_DL_NAME_CONVERTER, DSO_R_NAME_TRANSLATION_FAILED);
        return (NULL);
    }
    if (transform) {
        if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
            sprintf(translated, "lib%s%s", filename, extension);
        else
            sprintf(translated, "%s%s", filename, extension);
    } else
        sprintf(translated, "%s", filename);
    return (translated);
}

static int dl_pathbyaddr(void *addr, char *path, int sz)
{
    struct shl_descriptor inf;
    int i, len;

    if (addr == NULL) {
        union {
            int (*f) (void *, char *, int);
            void *p;
        } t = {
            dl_pathbyaddr
        };
        addr = t.p;
    }

    for (i = -1; shl_get_r(i, &inf) == 0; i++) {
        if (((size_t)addr >= inf.tstart && (size_t)addr < inf.tend) ||
            ((size_t)addr >= inf.dstart && (size_t)addr < inf.dend)) {
            len = (int)strlen(inf.filename);
            if (sz <= 0)
                return len + 1;
            if (len >= sz)
                len = sz - 1;
            memcpy(path, inf.filename, len);
            path[len++] = 0;
            return len;
        }
    }

    return -1;
}

static void *dl_globallookup(const char *name)
{
    void *ret;
    shl_t h = NULL;

    return shl_findsym(&h, name, TYPE_UNDEFINED, &ret) ? NULL : ret;
}
#endif                          /* DSO_DL */


text:
date: 2009-02-21
type: "Meeting"
title: Wifi Hacking
---
This Thursday [2/26], Alek will be showing us how to hack into a wifi network.

Topics covered will be:

  - Overview of why you would want to hack wifi
  - Hacking tools
  - What WEP is and how it works, flaws etc
  - How to hack WEP
  - Overview of what WPA/WPA2 is and how it works, flaws etc
  - How to Hack WPA/WPA2
  - Man-in-the-middle attacks [if time allows]

By the end of this meeting you'll have the wisdom needed to go out and break into wireless networks....your own of course!!!

As always, the meeting will be at 7p in Dreese 266.


text:
Für Entwickler, die ein davon wie Verständnis man die Cordova CLI verwenden und über Plugins verwenden, es gibt ein paar Dinge, die Sie sollten in Erwägung ziehen, neben Build besser, mehr Performant Cordova Anwendungen untersucht. Das folgende Dokument bietet Beratung zu verschiedenen Themen rund um Empfehlungen, Tests, Upgrades und anderen Themen, aber soll nicht präskriptiv sein. Betrachten Sie Ihren Startpunkt für Ihr Wachstum als Entwickler Cordova. Auch, wenn Sie etwas, die verbessert werden können sehen, bitte [beitragen][1]!

 [1]: http://cordova.apache.org/#contribute

Dieses Handbuch enthält die folgenden Themen:

*   Best Practices
*   Umgang mit Upgrades
*   Testen
*   Debuggen
*   Benutzeroberfläche
*   Halten
*   Anfordern von Hilfe

# Best Practices

## 1) SPA ist dein Freund

Zuallererst - sollten Ihre Cordova-Anwendungen das Design SPA (Single Seite Anwendung) annehmen. Lose definiert, ist ein SPA eine Client-Anwendung, die aus einer Anforderung einer Webseite ausgeführt wird. Der Benutzer lädt einen Anfangssatz von Ressourcen (HTML, CSS und JavaScript) und weitere Updates (zeigt eine neue Ansicht, Laden von Daten) erfolgt über AJAX. Thermen werden häufig für komplexere clientseitige Anwendungen verwendet. Google Mail ist ein gutes Beispiel dafür. Laden Sie Google Mail e-Mail-Ansichten, Bearbeitung und Organisation erfolgen alle durch Aktualisierung das DOM statt tatsächlich die aktuelle Seite zu verlassen um ein völlig neues laden.

Mit einem SPA kann Ihnen helfen, Ihre Anwendung in effizienter Weise zu organisieren, aber es hat auch bestimmte Vorteile für Cordova Anwendungen. Eine Cordova-Anwendung muss warten, für das Deviceready-Ereignis ausgelöst, bevor alle Plug-ins verwendet werden kann. Wenn Sie keinen SPA verwenden und Ihre Benutzer klickt, um von einer Seite zur anderen zu gehen, müssen Sie warten für Deviceready erneut ausgelöst, bevor Sie machen über ein Plugin zu verwenden. Dies ist einfach zu vergessen, da Ihre Anwendung größer wird.

Selbst wenn Sie nicht mithilfe von Cordova, wird mobile Application erstellen, ohne die Verwendung einer einzelnen Seitenarchitektur Leistung auswirken. Dies ist denn Navigieren zwischen den Seiten erforderlich sein, Vermögenswerte, Skripte, etc. neu geladen werden. Auch wenn diese Vermögenswerte zwischengespeichert werden, wird es Sie noch Leistungsprobleme.

Beispiele für SPA-Bibliotheken, die Sie in Ihren Cordova-Anwendungen verwenden können sind:

*   [AngularJS][2]
*   [Rückgrat][3]
*   [Kendo UI][4]
*   [Monaca][5]
*   [ReactJS][6]
*   [Sencha Touch][7]
*   [jQuery Mobile][8]

 [2]: http://angularjs.org
 [3]: http://backbonejs.org
 [4]: http://www.telerik.com/kendo-ui
 [5]: http://monaca.mobi/en/
 [6]: http://facebook.github.io/react/
 [7]: http://www.sencha.com/products/touch/
 [8]: jquerymobile.com

Und viele, viele mehr.

## 2) Überlegungen zur Leistung

Einer der größten Fehler, den, die ein neuer Cordova-Entwickler leisten kann, ist anzunehmen, dass die Leistung, die sie auf einem desktop-Rechner bekommen das gleiche erhalten sie auf einem mobilen Gerät. Zwar unsere mobile Geräte leistungsfähiger jedes Jahr bekommen, es fehlen noch die Kraft und die Leistung eines Desktop-Computers. Mobile Geräte haben in der Regel viel weniger RAM und eine GPU, die weit entfernt von ihrem Desktop (oder auch Laptop) Brüder. Eine vollständige Liste der Tipps hier wäre zu viel, aber hier sind ein paar Dinge zu beachten (mit einer Liste von mehr Ressourcen am Ende für die weitere Forschung).

**Klicken Sie im Vergleich zu Touch** - der größte und einfachste Fehler, den Sie machen können ist, Click-Ereignisse verwenden. Während diese "prima Mobile funktionieren", erheben die meisten Geräte 300ms Verzögerung darauf Unterscheidung zwischen einem Hauch und ein Hauch "halten"-Ereignis. Mit `touchstart` , oder `touchend` , führt zu einer dramatischen Verbesserung - 300ms nicht klingt wie viel, aber es ruckelt UI-Updates und Verhalten führen kann. Außerdem sollten Sie die Tatsache, die "Ereignisse berühren" werden nicht unterstützt auf nicht-Webkit-Browser finden Sie unter [CanIUse][9]. Um diese Einschränkungen zu begegnen, können Sie Kasse verschiedene Bibliotheken wie HandJS und Fastouch.

 [9]: http://caniuse.com/#search=touch

**CSS-Transitions gegenüber DOM-Manipulation** - mit Hilfe des Hardware-beschleunigte CSS Übergänge werden dramatisch besser als JavaScript verwendet, um Animationen zu erstellen. Finden Sie unter der Liste der Ressourcen am Ende dieses Abschnitts für Beispiele.

**Netzwerke zu saugen** - Ok, Netzwerke nicht immer saugen, aber die Wartezeit von Mobilfunknetzen, selbst gute Mobilfunknetzen, ist weit schlimmer sein als Sie vielleicht denken. Eine desktop-Anwendung, die alle 30 Sekunden nach unten über 500 Zeilen von JSON-Daten, schlürft werden beide langsamer auf einem mobilen Gerät sowie ein Batterie-Schwein. Beachten Sie, dass Cordova apps mehrere Möglichkeiten haben, Daten in der app (LocalStorage und das Dateisystem z. B.) beibehalten. Diese Daten lokal zwischengespeichert und werden bewusst die Datenmenge, die Sie hin und her senden. Dies ist ein besonders wichtiger Aspekt, wenn Ihre Anwendung über ein Mobilfunknetz verbunden ist.

**Zusatzvorstellung Artikel und Ressourcen**

*   ["Sie halb assed es"][10]
*   ["Top zehn Tipps zur Leistungssteigerung für PhoneGap und Hybrid-Apps"][11]
*   "Schnelle Apps und Websites mit JavaScript": http://channel9.msdn.com/Events/Build/2013/4-313

 [10]: http://sintaxi.com/you-half-assed-it
 [11]: http://coenraets.org/blog/2013/10/top-10-performance-techniques-for-phonegap-and-hybrid-apps-slides-available/

## 3) erkennen und behandeln von Offline-Status

Finden Sie im vorherigen Tipp über Netzwerke. Nicht nur Sie können über ein langsames Netzwerk, es ist durchaus möglich, für Ihre Anwendung komplett offline sein. Die Anwendung sollte dies auf intelligente Weise behandeln. Wenn Ihre Anwendung nicht tut, wird glauben, dass Ihre Anwendung unterbrochen wird. Gegeben wie einfach es ist, (Cordova unterstützt hören für ein Offline- und Ereignis) zu behandeln gibt es absolut keinen Grund für Ihre Anwendung nicht mehr reagiert, wenn offline ausführen. Testen Sie (siehe Abschnitt Testing) Ihre Anwendung und sollten Sie testen, wie Ihre Anwendung behandelt, wenn Sie in einem Staat starten und dann zu einer anderen wechseln.

Beachten Sie, dass die Online- und offline-Veranstaltungen sowie die Netzwerk-Verbindung-API ist nicht perfekt. Sie müssen möglicherweise verlassen sich auf mithilfe einer XHR-Anforderung um zu sehen, ob das Gerät wirklich offline oder online ist. Am Ende des Tages werden sicher irgendeine Form der Unterstützung für Netzwerkprobleme - fügen Sie in der Tat, im Apple Store (und wahrscheinlich noch andere Läden) werden apps, die ordnungsgemäß offline/online-Staaten darstellen nicht ablehnen. Weitere Diskussion zu diesem Thema finden Sie unter ["Ist das Ding auf?"][12]

 [12]: http://blogs.telerik.com/appbuilder/posts/13-04-23/is-this-thing-on-%28part-1%29

# Umgang mit Upgrades

## Update von Cordova-Projekten

Wenn das vorhandene Projekt erstellt wurde, mithilfe von Cordova 3.x, können Sie das Projekt aktualisieren, indem Folgendes ausgeben:

    cordova platform update platform-name ios, android, etc.

Wenn das vorhandene Projekt, unter einer Version vor Cordova erstellt wurde 3.x, es wäre wohl am besten ein neues Cordova-3.x-Projekt erstellen und kopieren Sie dann des vorhandenen Projekts Code und Vermögenswerte in das neue Projekt. Typische Schritte:

*   Erstellen eines neuen Cordova-3.x-Projekts (Cordova erstellen...)
*   Kopieren Sie den Www-Ordner aus dem alten Projekt zum neuen Projekt
*   Kopieren Sie alle Konfigurationseinstellungen aus dem alten Projekt in das neue Projekt
*   Fügen Sie alle Plugins in das alte Projekt in das neue Projekt verwendet
*   Erstellen Sie das Projekt
*   Testen, testen, testen!

Unabhängig von der vorherigen Version des Projekts ist es absolut wichtig, dass Sie lesen auf was in der aktualisierten Version geändert wurde, da das Update den Code brechen kann. Der beste Ort, um diese Informationen werden in den Release-Notes in den Repositories und auf dem Cordova-Blog veröffentlicht. Sie wollen Ihre Anwendung gründlich testen, um festzustellen, ob es ordnungsgemäß ausgeführt wird, nachdem Sie das Update durchführen.

Hinweis: einige Plugins kompatibel mit der neuen Version von Cordova möglicherweise nicht. Wenn eine Plugin nicht kompatibel ist, möglicherweise um ein Ersatz-Plugin zu finden, die tut, was Sie brauchen können, oder müssen Sie möglicherweise verzögern, Aktualisierung des Projekts. Alternativ ändern Sie das Plugin so, dass es unter der neuen Version arbeiten und zurück zur Gemeinschaft beitragen.

## Plugin-Upgrades

Ab Cordova 3.4 gibt es keinen Mechanismus für die Aktualisierung geänderte Plugins mithilfe eines einzelnen Befehls. Stattdessen entfernen Sie das Plugin zu, und fügen Sie sie zurück zu Ihrem Projekt und die neue Version installiert werden:

    cordova plugin rm com.some.plugin
    cordova plugin add com.some.plugin

Achten Sie darauf, das aktualisierte Plugin Dokumentation, zu kontrollieren, Sie benötigen, um Ihren Code zum Arbeiten mit der neuen Version anzupassen. Auch, doppelt überprüfen, die die neue Version des Plugins mit Ihrem Projekt Version von Cordova.

Testen Sie stets Ihre apps um sicherzustellen, dass das neue Plugin installieren nicht etwas gebrochen hat, die Sie nicht vorhersah.

Wenn Ihr Projekt viele Plugins, die Sie benötigen aktualisiert hat, könnte es sparen Sie Zeit eine Shell oder Batch-Skript erstellen, das entfernt und die Plugins mit einem einzigen Befehl hinzugefügt.

# Testen

Testen Ihrer Anwendungen ist super wichtig. Das Cordova-Team nutzt Jasmin aber Web-verbündete Einheit-Testlösung wird.

## Am Simulator vs. auf einem echten Gerät testen

Es ist nicht ungewöhnlich, dass desktop-Browsern und Gerät-Simulatoren/Emulatoren verwenden Sie beim Entwickeln einer Anwendung von Cordova. Allerdings ist es unglaublich wichtig, dass Sie Ihre Anwendung auf so viele physische Geräte testen wie du nur kannst:

*   Simulatoren sind genau das: Simulatoren. Beispielsweise Ihre Anwendung in der iOS-Simulator ohne Probleme funktionieren, aber es möglicherweise nicht auf einem echten Gerät (vor allem in bestimmten Umständen, wie etwa einen Speichermangel-Zustand). Oder Ihre app versäumen tatsächlich auf dem Simulator, während es auf einem echten Gerät einwandfrei funktioniert.
*   Emulatoren sind genau das: Emulatoren. Sie repräsentieren nicht, wie gut Ihre app auf einem physischen Gerät ausgeführt werden. Einige Emulatoren können beispielsweise Ihre app mit einer verstümmelten Anzeige gerendert, während ein echtes Gerät kein Problem hat. (Wenn Sie dieses Problem auftritt, deaktivieren Sie den Host GPU im Emulator.)
*   Simulatoren sind in der Regel schneller als Ihr physisches Gerät. Emulatoren sind auf der anderen Seite im allgemeinen langsamer. Beurteilen Sie die Leistung Ihrer Anwendung nicht, von wie es in einem Simulator oder einen Emulator durchführt. Beurteilen Sie die Leistung Ihrer Anwendung von wie es auf ein Spektrum an realen Geräten läuft.
*   Es ist unmöglich, ein gutes Gefühl dafür, wie Ihre app auf Ihrem Touch reagiert, mit einem Simulator oder einen Emulator. Stattdessen kann die app auf einem echten Gerät ausgeführt Probleme mit den Größen der Elemente der Benutzeroberfläche, Reaktionsfähigkeit, usw. hinweisen.
*   Obwohl es schön wäre, nur auf ein Gerät pro Plattform testen zu können, empfiehlt es sich, bei vielen Geräten sportliche viele verschiedene OS-Versionen zu testen. Z. B. was auf Ihrem bestimmten Android-Smartphone funktioniert auf einem anderen Android-Gerät möglicherweise nicht. Was auf einem iOS 7-Gerät funktioniert möglicherweise nicht auf einem Gerät mit iOS 6.

Es ist natürlich unmöglich, auf alle möglichen Geräte auf dem Markt zu testen. Aus diesem Grund ist es ratsam viele Tester einstellen, die verschiedene Geräte zu haben. Obwohl sie jedes Problem wird nicht fangen, stehen die Chancen gut, dass sie entdecken werden, Macken und Probleme, die Sie allein nie finden würden.

Tipp: Es ist möglich auf Android Nexus Geräten leicht unterschiedliche Versionen von Android auf das Gerät flashen. Dieser einfache Prozess können Sie Ihre Anwendung auf verschiedenen Ebenen von Android mit einem einzigen Gerät, leicht zu testen, ohne Ihre Garantie annullieren oder dass Sie Ihr Gerät auf "Jailbreak" oder "Root". Die Google Android Fabrik Bilder und Anleitungen befinden sich in: https://developers.google.com/android/nexus/images#instructions

# Debuggen

Debuggen von Cordova, muss ein Setup. Im Gegensatz zu einer desktop-Anwendung Sie können nicht öffnen Sie einfach Dev Tools auf Ihrem mobilen Gerät und Debuggen starten, zum Glück gibt es einige tolle Alternativen.

## Safari Remotedebuggen

Die erste Option ist Safari Remotedebuggen. Dies funktioniert nur unter OSX und nur mit iOS 6 (und höher). Es verwendet Safari zum Herstellen einer Verbindung mit Ihrem Gerät (oder der Simulator) und wird die Browser-Dev-Tools der Cordova-Anwendung verbinden. Sie bekommen, was Sie von Entwicklungstools - DOM Inspektion/Manipulation, einen JavaScript-Debugger, Netzwerk-Inspektion, die Konsole und mehr erwarten. Weitere Einzelheiten finden Sie in diesem hervorragenden Blog-post: [http://moduscreate.com/enable-remote-web-inspector-in-ios-6/][13]

 [13]: http://moduscreate.com/enable-remote-web-inspector-in-ios-6/]

## Chrom Remotedebuggen

Praktisch das gleiche wie der Safari-Version, dies funktioniert nur mit Android, sondern kann von jedem desktop-Betriebssystem verwendet werden. Es erfordert mindestens Android 4.4 (KitKat), API-Mindestmaß an 19 und Chrom 30 + (auf dem Desktop). Sobald verbunden, erhalten Sie die gleiche Chrome Dev Tools-Erfahrung für Ihre mobilen Anwendungen, wie Sie mit Ihrem desktop-Anwendungen. Noch besser ist, haben die Chrome Dev-Tools eine Spiegel-Option, die Ihre app-Betrieb auf dem mobilen Gerät zeigt. Dies ist mehr als nur eine Ansicht - Sie können aus Dev Tools klicken und scrollen und Aktualisierungen auf dem mobilen Gerät. Weitere Informationen zu Chrome Remotedebuggen finden Sie hier: <https://developers.google.com/chrome/mobile/docs/debugging>

Es ist möglich, Chrome Dev Tools verwenden, um iOS apps, über einen WebKit-Proxy zu prüfen: <https://github.com/google/ios-webkit-debug-proxy/>

## Welligkeit

Welligkeit ist ein desktop basierten Emulator für Cordova-Projekte. Im Wesentlichen können Sie eine Cordova-Anwendung in der desktop-Anwendung ausführen und fake verschiedene Cordova-Features. Beispielsweise können Sie den Beschleunigungsmesser um zu testen, Shake-Veranstaltungen zu simulieren. Es täuscht die Kamera-API, indem man Ihnen ein Bild von Ihrer Festplatte auszuwählen. Welligkeit können, die Sie mehr auf Ihren benutzerdefinierten Code, anstatt sich Gedanken über Cordova Plugins konzentrieren. Erfahren Sie mehr über Ripple hier: <http://ripple.incubator.apache.org/>

## Weinre

Weinre erstellt einen lokalen Server, der einen remote-Debug-Client für Ihre Cordova-Anwendungen hosten kann. Nachdem Sie installiert und es gestartet haben, können Sie eine Codezeile in Cordova Anwendung kopieren und starten Sie ihn neu. Sie können dann eine Dev-Tool-Leiste auf dem Desktop mit der Anwendung öffnen. Weinre ist nicht ganz so hochtrabend als Chrome und Safari Remotedebuggen, hat aber den Vorteil der Arbeit mit einem viel größeren Bereich der Betriebssysteme und Plattformen. Weitere Informationen finden Sie hier: <http://people.apache.org/~pmuellr/weinre/docs/latest/>

## Andere Optionen

*   BlackBerry 10 unterstützt auch Debuggen: [Dokumentation][14]
*   Sie können mit Firefox App Manager sowie Debuggen, finden Sie unter [diesem Blog-Post][15] und dieser [MDN-Artikel][16].
*   Weitere Beispiele und Erläuterung der oben genannten Tipps zum Debuggen finden Sie unter: <http://developer.telerik.com/featured/a-concise-guide-to-remote-debugging-on-ios-android-and-windows-phone/>

 [14]: https://developer.blackberry.com/html5/documentation/v2_0/debugging_using_web_inspector.html
 [15]: https://hacks.mozilla.org/2014/02/building-cordova-apps-for-firefox-os/
 [16]: https://developer.mozilla.org/en-US/Apps/Tools_and_frameworks/Cordova_support_for_Firefox_OS#Testing_and_debugging

# Benutzeroberfläche

Erstellen einer Anwendung Cordova sieht schön auf mobile eine Herausforderung sein kann, vor allem für Entwickler. Viele Menschen haben ein UI-Framework verwenden, um dies zu erleichtern. Hier ist eine kurze Liste der Optionen, die Sie betrachten möchten.

*   [jQuery Mobile][8] - jQuery Mobile erhöht automatisch Ihre Layout für mobile Optimierung. Es behandelt auch einen SPA für Sie automatisch erstellen.
*   [Ionische][17] -dieser leistungsstarke UI-Framework hat tatsächlich eigene CLI Projekterstellung zu behandeln.
*   [Ratsche][18] - geholt Ihnen durch die Menschen, die Bootstrap erstellt.
*   [Kendo UI][4] - Open-Source-UI und Application Framework von Telerik.
*   [DECKLACK][19]
*   [ReactJS][6]

 [17]: http://ionicframework.com/
 [18]: http://goratchet.com/
 [19]: http://topcoat.io

Wenn Sie Ihre Benutzeroberfläche zu erstellen, ist es wichtig, über alle Plattformen, die Sie abzielen und die Unterschiede zwischen den Benutzererwartungen zu denken. Beispielsweise wird eine Android-Anwendung, die Benutzeroberfläche eines iOS-Stil hat wahrscheinlich nicht gut mit Benutzer rüber. Dies wird manchmal auch durch die verschiedene Anwendung-Stores erzwungen. Aus diesem Grund ist es wichtig, dass Sie die Konventionen der jede Plattform respektieren und daher vertraut mit den verschiedenen Human Interface Guidelines sind: * [iOS][20] * [Android][21] * [Windows Phone][22]

 [20]: https://developer.apple.com/library/ios/documentation/userexperience/conceptual/MobileHIG/index.html
 [21]: https://developer.android.com/designWP8
 [22]: http://dev.windowsphone.com/en-us/design/library

## Zusätzliche UI-Artikel und Betriebsmittel

Obwohl Browser-Motoren immer mehr Normen Beschwerde geworden, wir leben noch in einer vorangestellten Welt (-Webkit und - Frau) der folgende Artikel ist wertvoll, wenn UI in für cross-Browser-apps entwickeln: <http://blogs.windows.com/windows_phone/b/wpdev/archive/2012/11/15/adapting-your-webkit-optimized-site-for-internet-explorer-10.aspx>

# Halten

Hier sind ein paar Möglichkeiten, um mit Cordova aktuell zu halten.

*   Abonnieren Sie den [Blog von Cordova][23].
*   Abonnieren Sie die [Liste der Entwickler][24]. Hinweis: Dies ist keine Selbsthilfegruppe! Vielmehr ist dies ein Ort, wo die Entwicklung von Cordova diskutiert wird.

 [23]: http://cordova.apache.org/#news
 [24]: http://cordova.apache.org/#mailing-list

# Anfordern von Hilfe

Die folgenden Links sind die besten Orte, um Hilfe zu Cordova zu erhalten:

*   StackOverflow: <http://stackoverflow.com/questions/tagged/cordova> mit dem Cordova-Tag, Sie können anzeigen und durchsuchen alle Cordova Fragen. Beachten Sie, dass StackOverflow automatisch das "Phonegap" Tag "Cordoba", konvertiert so dass auf diese Weise werden Sie historische Fragen sowie Zugang zu
*   PhoneGap Google Group: [https://groups.google.com/forum/#! Forum/Phonegap][25] diese Google Group war das alte Support-Forum für wann Cordova noch PhoneGap genannt wurde. Zwar es noch eine Menge von Cordova-Benutzer, die dieser Gruppe häufig gibt, hat die Gemeinde Cordova ein Interesse an Konzentration weniger auf diese Gruppe und stattdessen StackOverflow für Unterstützung geäußert.
*   Meetup: <http://phonegap.meetup.com> - betrachten Sie suchen nach einer lokalen Cordova/PhoneGap Meetup-Gruppe

 [25]: https://groups.google.com/forum/#!forum/phonegap


text:
function [tLngDefrag,amDefrag,pmDefrag] = sortAM(tLngDefrag,amDefrag,pmDefrag)
% function to rewrite pmDefrag / amDefrag / tLngDefrag and to sort it
%
%   [tLngDefrag,amDefrag,pmDefrag] = sortAM(tLng,am,pm)
%
%
%
%
%
% tim becker, 2010-2011

%
% first, we write all paths at the end of the timeline
% we start at the end and search for the first free
% position,
%

% we need enough empty space
% we double the size of amDefrag(pmDefrag
% (this is ok, am is sparse, and pm empty, -> only
%  very little memory is needed )
n = size(amDefrag,1);

amDefrag(2*n,2*n) = 0;
pmDefrag(2*n,:) = {[] [] [] []};

% we extract all paths and all empty paths
pathList = evaluatePathStatus(pmDefrag,1);
emptyList = setdiff(1:length(pmDefrag),pathList);

% we move all paths to the end and all empty ones
% to the beginning
[tLngDefrag,amDefrag,pmDefrag,changeList] = defragAM(tLngDefrag,amDefrag,...
    pmDefrag,pathList,emptyList);

% to check if the all empty paths are shifted to the beginning:
%pathList = evaluatePathStatus(pmDefrag,1);
%emptyList = setdiff(1:length(pmDefrag),pathList);
%isequal(emptyList,1:length(emptyList))

%% reorder paths (tree by tree)
% get lineages
[treeList,treeRelationList,lm,treeLength] = getLineages(amDefrag,pmDefrag);
pathList2 = evaluatePathStatus(pmDefrag,1);
pathList = [];

%
for iPath=1:length(pmDefrag)
    if ~isempty(pmDefrag{iPath,1})
        pathList = [pathList,iPath];
    end
end
emptyList = setdiff(1:length(pmDefrag),pathList);

tList = [];
for i=1:length(treeList)
    tList = [tList; treeList{i}(:)];
end
noTreeList = setdiff(pathList,tList);

%%
for iTree = 1:length(treeList)
    tree = treeList{iTree};
    pathList = evaluatePathStatus(pmDefrag,1);
    emptyList = setdiff(1:length(pmDefrag),pathList);
    [tLngDefrag,amDefrag,pmDefrag] = defragAM(tLngDefrag,amDefrag,...
    pmDefrag,tree,emptyList(end:-1:1));
end

%
% todo: notEmptyPathlist <- k.a. was ich da meinte, hat das
% noch bedeutung?
%
 pathList = evaluatePathStatus(pmDefrag,1);
 emptyList = setdiff(1:length(pmDefrag),pathList);
 [tLngDefrag,amDefrag,pmDefrag] = defragAM(tLngDefrag,amDefrag,...
     pmDefrag,noTreeList,emptyList(end:-1:1));

%%

pathnumber = length(pathList);
% the last step: we delete all empty paths
amDefrag = amDefrag(1:pathnumber,1:pathnumber);
pmDefrag = pmDefrag(1:pathnumber,:);


text:
package review.utils.mybe.outdated;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.io.FileUtils;

public class ProcessIncomingData {

	static String encoding = "UTF-8";

	static Integer globalCount = 0;
	static HashMap<String, Integer> map = new HashMap<>();

	public static void main(String[] args) throws IOException {
		File resultFile = new File("D:/RND/VM_Dev/test-results-docker/spark_baseline_dev_1/computationResults.txt");
		File benchFile = new File("D:/RND/VM_Dev/test-results-docker/spark_baseline_dev_1/computationResults.bench");
		List<String> kafkaResults = FileUtils.readLines(resultFile, encoding);

		for (String string : kafkaResults) {

			String[] sp = string.split(" ");

			globalCount += Integer.parseInt(sp[3]);
			if (map.containsKey(sp[0])) {
				Integer newValue = Integer.parseInt(sp[3]);
				map.replace(sp[0], map.get(sp[0]) + newValue);
			} else {
				map.put(sp[0], Integer.parseInt(sp[3]));
			}

			if (map.containsKey(sp[1])) {
				Integer newValue = Integer.parseInt(sp[3]);
				map.replace(sp[1], map.get(sp[0]) + newValue);
			} else {
				map.put(sp[1], Integer.parseInt(sp[3]));
			}

		}

		for (Map.Entry<String, Integer> entry : map.entrySet()) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " " + value);
			FileUtils.write(benchFile, key + " " + value + System.lineSeparator(), encoding, true);
		}

		FileUtils.write(benchFile, globalCount + "" + System.lineSeparator(), encoding, true);
	}

	public static ArrayList<String> shrinkToIDandLat(List<String> inputList) throws IOException {
		ArrayList<String> outputList = new ArrayList<>();

		for (String oneLineOfData : inputList) {

			String[] splittedData = oneLineOfData.split(" ");
			String newLineOfData = splittedData[0] + " " + splittedData[3];

			outputList.add(newLineOfData);
		}
		return outputList;
	}

	public static List<String> sortyById(List<String> inputList) throws IOException {
		Collections.sort(inputList, new Comparator<String>() {
			@Override
			public int compare(String data01, String data02) {
				Integer value1 = Integer.parseInt(data01.split(" ")[0]);
				Integer value2 = Integer.parseInt(data02.split((" "))[0]);

				return (value1 < value2 ? -1 : (value1 == value2 ? 0 : 1));
			}
		});
		return inputList;
	}
}


text:
Asbestos
========

Template handler for Rails that allows you to use
a subset of XML Builder markup to produce JSON.

Take, for instance, a common "show.xml.builder" template:

    xml.instruct!
    xml.category(:private => false) do
      xml.name @category.name
      xml.parent do
        xml.id @category.parent_id
        xml.name @category.parent.name
      end
    end

If you copied that to "show.json.asbestos", you would get:

    {"category": {
      "private": "false",
      "name": "Science & Technology",
      "parent": {
        "id": 1,
        "name": "Religion"
      }
    }}

But of course, you don't want to duplicate your builder template
in another file, so we'll handle this in the controller:

    def show
      respond_to do |wants|
        wants.xml
        wants.json {
          # takes the "show.xml.builder" template and renders it to JSON
          render_json_from_xml
        }
      end
    end

With this method there's no need for a special template file for JSON.
Asbestos is designed to use existing XML Builder templates.

How does it work?
-----------------

The `xml` variable in your normal builder templates is the XML Builder object.
When you call methods on this object, it turns that into XML nodes and appends
everything to a string, which is later returned as the result of rendering.

This plugin provides Asbestos::Builder, which tries to mimic the behavior
of the XML Builder while saving all the data to a big nested ruby hash.
In the end, `to_json` is called on it.

Aggregates and ignores (important!)
-----------------------------------

Problems start when you have Builder templates that render *collections*,
like in index actions:

    xml.instruct!
    for category in @categories
      xml.category do
        # ...
      end
    end

There is a ruby loop in there, so if there are multiple categories the resulting
JSON would have just one. This is because the same "category" field in the JSON
hash would keep getting re-written by the next iteration. Asbestos::Builder is,
unfortunately, not aware about any loops in your template code.

The solution is to indicate explicitly which keys you want aggregated:

    render_json_from_xml :aggregate => ['category']

Now, what would previously create a "category" key will get aggregated
under a "categories" array, instead:

    { "categories": [ ... ] }

Sometimes, most often with root elements, you want a key ignored.
You can specify which occurrences to ignore:

    render_json_from_xml :ignore => ['category']


text:
namespace SquaredEngine.PathEditor.Library {
	public enum PathEditorTools {
		Move = 0,
		Add = 1,
		Remove = 2,
		Split = 3
	}
}


text:
using System;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using ESRI.ArcGIS.Client;
using ESRI.ArcGIS.Client.Geometry;
using ESRI.ArcGIS.Client.Symbols;

namespace ArcGISSilverlightSDK
{
    public partial class GeometryJson : UserControl
    {
        GraphicsLayer _myToJsonGraphicsLayer;
        GraphicsLayer _myFromJsonGraphicsLayer;
        Draw _myDrawObject;

        string jsonPoint = @"{""x"":-100.609,""y"":43.729,""spatialReference"":{""wkid"":4326}}";

        string jsonPolyline = @"{""paths"":[[[0,51.399],
[2.637,48.865],
[12.568,41.706],
[13.447,52.483],
[21.357,52.160],
[30.322,59.845]]],
""spatialReference"":{""wkid"":4326}}";

        string jsonPolygon = @"{""rings"":[[[110.039,-20.303],
[132.539,-7.0137],
[153.281,-13.923],
[162.773,-35.174],
[133.594,-43.180],
[111.797,-36.032],
[110.039,-20.303]]],
""spatialReference"":{""wkid"":4326}}";

        string jsonEnvelope = @"{""xmin"" : -109.55, ""ymin"" : 25.76,
""xmax"" : -86.39, ""ymax"" : 49.94,
""spatialReference"" : {""wkid"" : 4326}}";

        public GeometryJson()
        {
            InitializeComponent();

            _myFromJsonGraphicsLayer = MyMap.Layers["MyFromJsonGraphicsLayer"] as GraphicsLayer;
            _myToJsonGraphicsLayer = MyMap.Layers["MyToJsonGraphicsLayer"] as GraphicsLayer;
            InJsonTextBox.Text = jsonPoint;

            _myDrawObject = new Draw(MyMap)
            {
                LineSymbol = LayoutRoot.Resources["DrawLineSymbol"] as LineSymbol,
                FillSymbol = LayoutRoot.Resources["DrawFillSymbol"] as FillSymbol
            };
            _myDrawObject.DrawComplete += MyDrawObject_DrawComplete;
        }

        private void ResetButton_Click(object sender, RoutedEventArgs e)
        {
            ClearGraphicsLayers();
            InJsonTextBox.Text = "";
            OutJsonTextBox.Text = "";
        }

        private void PointJsonButton_Click(object sender, RoutedEventArgs e)
        {
            ClearGraphicsLayers();
            InJsonTextBox.Text = jsonPoint;
        }

        private void PolylineJsonButton_Click(object sender, RoutedEventArgs e)
        {
            ClearGraphicsLayers();
            InJsonTextBox.Text = jsonPolyline;
        }

        private void PolygonJsonButton_Click(object sender, RoutedEventArgs e)
        {
            ClearGraphicsLayers();
            InJsonTextBox.Text = jsonPolygon;
        }

        private void EnvelopeJsonButton_Click(object sender, RoutedEventArgs e)
        {
            ClearGraphicsLayers();
            InJsonTextBox.Text = jsonEnvelope;
        }

        private void ClearGraphicsLayers()
        {
            _myToJsonGraphicsLayer.Graphics.Clear();
            _myFromJsonGraphicsLayer.Graphics.Clear();
        }

        private void ApplyButton_Click(object sender, RoutedEventArgs e)
        {
            ClearGraphicsLayers();
            OutJsonTextBox.Text = "";

            try
            {
                // Convert from Geometry to ArcGIS REST geometry json
                Geometry geometry = Geometry.FromJson(InJsonTextBox.Text);

                Graphic graphic = new Graphic();

                if (geometry is MapPoint)
                    graphic.Symbol = LayoutRoot.Resources["RedMarkerSymbol"] as SimpleMarkerSymbol;
                else if (geometry is Polyline)
                    graphic.Symbol = LayoutRoot.Resources["RedLineSymbol"] as SimpleLineSymbol;
                else if (geometry is Polygon)
                    graphic.Symbol = LayoutRoot.Resources["RedFillSymbol"] as SimpleFillSymbol;
                else if (geometry is Envelope)
                    graphic.Symbol = LayoutRoot.Resources["RedFillSymbol"] as SimpleFillSymbol;

                if (graphic.Symbol != null)
                {
                    graphic.Geometry = geometry;
                    _myFromJsonGraphicsLayer.Graphics.Add(graphic);
                }
            }
            catch
            {
                MessageBox.Show("Unable to convert json into geometry");
            }
        }

        private void DrawGeometryButton_Click(object sender, RoutedEventArgs e)
        {
            ClearGraphicsLayers();
            OutJsonTextBox.Text = "";

            switch ((sender as Button).Tag as string)
            {
                case "DrawPoint":
                    _myDrawObject.DrawMode = DrawMode.Point;
                    break;
                case "DrawPolyline":
                    _myDrawObject.DrawMode = DrawMode.Polyline;
                    break;
                case "DrawPolygon":
                    _myDrawObject.DrawMode = DrawMode.Polygon;
                    break;
                case "DrawRectangle":
                    _myDrawObject.DrawMode = DrawMode.Rectangle;
                    break;
                default:
                    _myDrawObject.DrawMode = DrawMode.None;
                    ClearGraphicsLayers();
                    break;
            }
            _myDrawObject.IsEnabled = (_myDrawObject.DrawMode != DrawMode.None);
        }

        private void MyDrawObject_DrawComplete(object sender, ESRI.ArcGIS.Client.DrawEventArgs args)
        {
            ClearGraphicsLayers();

            Graphic graphic = new Graphic();
            if (args.Geometry is MapPoint)
                graphic.Symbol = LayoutRoot.Resources["BlueMarkerSymbol"] as SimpleMarkerSymbol;
            else if (args.Geometry is Polyline)
                graphic.Symbol = LayoutRoot.Resources["BlueLineSymbol"] as SimpleLineSymbol;
            else if (args.Geometry is Polygon)
                graphic.Symbol = LayoutRoot.Resources["BlueFillSymbol"] as SimpleFillSymbol;
            else if (args.Geometry is Envelope)
                graphic.Symbol = LayoutRoot.Resources["BlueFillSymbol"] as SimpleFillSymbol;

            if (graphic.Symbol != null)
            {
                graphic.Geometry = args.Geometry;
                _myToJsonGraphicsLayer.Graphics.Add(graphic);
            }

            // Convert from Geometry to ArcGIS REST geometry json
            OutJsonTextBox.Text = args.Geometry.ToJson();
        }

        private void TabControl_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (_myFromJsonGraphicsLayer != null || _myToJsonGraphicsLayer != null)
            {
                ClearGraphicsLayers();
                OutJsonTextBox.Text = "";
            }
            else
                return;

            if ((((sender as TabControl).SelectedItem as TabItem).Header as string) == "From JSON")
                _myDrawObject.IsEnabled = false;
        }
    }
}


text:
package cn.clxy.ssm.common.dao;

import java.util.Properties;

import javax.annotation.Resource;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

@Intercepts({
		@Signature(
				type = Executor.class,
				method = "update",
				args = { MappedStatement.class, Object.class }),
		@Signature(
				type = Executor.class,
				method = "query",
				args = { MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class }) })
public class MybatisInterceptor implements Interceptor {

	@Resource
	protected Handler daoHandler;

	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		return daoHandler.handle(invocation);
	}

	@Override
	public Object plugin(Object target) {
		return Plugin.wrap(target, this);
	}

	@Override
	public void setProperties(Properties properties) {
	}
}


text:
class EventsRequestsController < ApplicationController
  def create
    event_request = EventRequest.create(permitted_params)
    render json: event_request, status: :ok
  end

  private

  def permitted_params
    params.require(:events_request).permit(
      :name,
      :description,
      :date,
      :participants_number,
      :responsable_id,
      :office_id,
      :event_request_status_id,
      :event_type_id
    )
  end
end


text:
FROM ubuntu:bionic

COPY docker/scripts/segs.sh /tmp
RUN /tmp/segs.sh install_deps_ubuntu

VOLUME /segs
WORKDIR /segs

ENV PATH="/segs/docker/scripts:${PATH}"


text:
package com.fjsg.linggan.service.entity;

import com.fjsg.linggan.util.ToString;

/**
 * Áé¸ÐʵÌå¶ÔÏó
 *
 * @author zhaojun.wzj
 * @version $Id Linggan.java, v 0.1 2017-07-28 17:55 zhaojun.wzj Exp $$
 */
public class Linggan extends ToString {

    /** serialVersionUID */
    private static final long serialVersionUID = -7370649142615226771L;

    /** id */
    private Long              id;

    /** Óû§id */
    private String            userId;

    /** ÄÚÈÝ, ÔÝʱֻ֧³ÖÎı¾ÀàÐÍ */
    private String            content;

    /**
     * Áé¸ÐÀàÐÍ
     * @see com.fjsg.linggan.service.enums.LingganTypeEnum
     */
    private int               contentType;

    /** createTime */
    private long              createTime;

    /** lastModified */
    private long              lastModified;

    /**
     * Getter method for property <tt>id</tt>.
     *
     * @return property value of id
     */
    public Long getId() {
        return id;
    }

    /**
     * Setter method for property <tt>id</tt>.
     *
     * @param id value to be assigned to property id
     */
    public void setId(Long id) {
        this.id = id;
    }

    /**
     * Getter method for property <tt>userId</tt>.
     *
     * @return property value of userId
     */
    public String getUserId() {
        return userId;
    }

    /**
     * Setter method for property <tt>userId</tt>.
     *
     * @param userId value to be assigned to property userId
     */
    public void setUserId(String userId) {
        this.userId = userId;
    }

    /**
     * Getter method for property <tt>content</tt>.
     *
     * @return property value of content
     */
    public String getContent() {
        return content;
    }

    /**
     * Setter method for property <tt>content</tt>.
     *
     * @param content value to be assigned to property content
     */
    public void setContent(String content) {
        this.content = content;
    }

    /**
     * Getter method for property <tt>contentType</tt>.
     *
     * @return property value of contentType
     */
    public int getContentType() {
        return contentType;
    }

    /**
     * Setter method for property <tt>contentType</tt>.
     *
     * @param contentType value to be assigned to property contentType
     */
    public void setContentType(int contentType) {
        this.contentType = contentType;
    }

    /**
     * Getter method for property <tt>createTime</tt>.
     *
     * @return property value of createTime
     */
    public long getCreateTime() {
        return createTime;
    }

    /**
     * Setter method for property <tt>createTime</tt>.
     *
     * @param createTime value to be assigned to property createTime
     */
    public void setCreateTime(long createTime) {
        this.createTime = createTime;
    }

    /**
     * Getter method for property <tt>lastModified</tt>.
     *
     * @return property value of lastModified
     */
    public long getLastModified() {
        return lastModified;
    }

    /**
     * Setter method for property <tt>lastModified</tt>.
     *
     * @param lastModified value to be assigned to property lastModified
     */
    public void setLastModified(long lastModified) {
        this.lastModified = lastModified;
    }
}


text:
package spittr.web;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.thymeleaf.extras.springsecurity3.dialect.SpringSecurityDialect;
import org.thymeleaf.spring4.SpringTemplateEngine;
import org.thymeleaf.spring4.view.ThymeleafViewResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;
import org.thymeleaf.templateresolver.TemplateResolver;

@Configuration
@EnableWebMvc
@ComponentScan("spittr.web")
public class WebConfig extends WebMvcConfigurerAdapter {

  @Bean
  public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
    ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
    viewResolver.setTemplateEngine(templateEngine);
    return viewResolver;
  }
  @Bean
  public SpringTemplateEngine templateEngine(TemplateResolver templateResolver) {
    SpringTemplateEngine templateEngine = new SpringTemplateEngine();
    templateEngine.setTemplateResolver(templateResolver);
    templateEngine.addDialect(new SpringSecurityDialect());
    return templateEngine;
  }

  @Bean
  public TemplateResolver templateResolver() {
    TemplateResolver templateResolver = new ServletContextTemplateResolver();
    templateResolver.setPrefix("/WEB-INF/views/");
    templateResolver.setSuffix(".html");
    templateResolver.setTemplateMode("HTML5");
    return templateResolver;
  }

  @Override
  public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
    configurer.enable();
  }

  @Override
  public void addViewControllers(ViewControllerRegistry registry) {
    registry.addViewController("/login").setViewName("login");
  }

}


text:
package trees.bst;

import static org.junit.Assert.assertEquals;

import org.junit.Before;
import org.junit.Test;

public class BSTTest {

    private BST<String> classUnderTest;
    Node<String>        root;

    @Before
    public void beforeTest() {
        root = new Node<String>("C", null, null, 1);
        classUnderTest = new BST<>(root);
    }

    @Test
    public void testInsert() {
        classUnderTest.insert("B");
        assertEquals(2, classUnderTest.size());
        classUnderTest.insert("A");
        assertEquals(3, classUnderTest.size());
    }

    @Test
    public void testSize() {
        assertEquals(1, classUnderTest.size());
    }

    @Test
    public void testSearch() {
        assertEquals(true, classUnderTest.search("C"));
        assertEquals(false, classUnderTest.search("B"));
        classUnderTest.insert("B");
        assertEquals(true, classUnderTest.search("B"));
    }

    @Test
    public void testToString() {
        assertEquals("C () ()", classUnderTest.toString());
    }

    @Test
    public void testMin() {
        assertEquals("C", classUnderTest.min());
        classUnderTest.insert("B");
        assertEquals("B", classUnderTest.min());
        classUnderTest.insert("D");
        assertEquals("B", classUnderTest.min());
        classUnderTest.insert("A");
        assertEquals("A", classUnderTest.min());
    }

    @Test
    public void testMax() {
        assertEquals("C", classUnderTest.max());
        classUnderTest.insert("B");
        assertEquals("C", classUnderTest.max());
        classUnderTest.insert("D");
        assertEquals("D", classUnderTest.max());
        classUnderTest.insert("A");
        assertEquals("D", classUnderTest.max());
    }

    @Test
    public void testMinDelete() {
        assertEquals(true, classUnderTest.search("C"));
        classUnderTest.deleteMin();
        assertEquals(false, classUnderTest.search("C"));
        classUnderTest.insert("C");
        assertEquals(true, classUnderTest.search("C"));
        classUnderTest.insert("B");
        assertEquals(true, classUnderTest.search("B"));
        classUnderTest.deleteMin();
        assertEquals(false, classUnderTest.search("B"));
        assertEquals(true, classUnderTest.search("C"));
    }

    @Test
    public void testMaxDelete() {
        assertEquals(true, classUnderTest.search("C"));
        classUnderTest.deleteMax();
        assertEquals(false, classUnderTest.search("C"));
        classUnderTest.insert("C");
        assertEquals(true, classUnderTest.search("C"));
        classUnderTest.insert("B");
        assertEquals(true, classUnderTest.search("B"));
        classUnderTest.deleteMax();
        assertEquals(true, classUnderTest.search("B"));
        assertEquals(false, classUnderTest.search("C"));
    }
}


text:
#include <stdarg.h>

#define COBJMACROS

#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "rpcproxy.h"
#include "netfw.h"

#include "wine/debug.h"
#include "hnetcfg_private.h"

WINE_DEFAULT_DEBUG_CHANNEL(hnetcfg);

static HINSTANCE instance;

typedef HRESULT (*fnCreateInstance)( IUnknown *pUnkOuter, LPVOID *ppObj );

typedef struct
{
    IClassFactory IClassFactory_iface;
    fnCreateInstance pfnCreateInstance;
} hnetcfg_cf;

static inline hnetcfg_cf *impl_from_IClassFactory( IClassFactory *iface )
{
    return CONTAINING_RECORD(iface, hnetcfg_cf, IClassFactory_iface);
}

static HRESULT WINAPI hnetcfg_cf_QueryInterface( IClassFactory *iface, REFIID riid, LPVOID *ppobj )
{
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IClassFactory))
    {
        IClassFactory_AddRef( iface );
        *ppobj = iface;
        return S_OK;
    }
    FIXME("interface %s not implemented\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

static ULONG WINAPI hnetcfg_cf_AddRef( IClassFactory *iface )
{
    return 2;
}

static ULONG WINAPI hnetcfg_cf_Release( IClassFactory *iface )
{
    return 1;
}

static HRESULT WINAPI hnetcfg_cf_CreateInstance( IClassFactory *iface, LPUNKNOWN pOuter,
                                                  REFIID riid, LPVOID *ppobj )
{
    hnetcfg_cf *This = impl_from_IClassFactory( iface );
    HRESULT r;
    IUnknown *punk;

    TRACE("%p %s %p\n", pOuter, debugstr_guid(riid), ppobj);

    *ppobj = NULL;

    if (pOuter)
        return CLASS_E_NOAGGREGATION;

    r = This->pfnCreateInstance( pOuter, (LPVOID *)&punk );
    if (FAILED(r))
        return r;

    r = IUnknown_QueryInterface( punk, riid, ppobj );
    if (FAILED(r))
        return r;

    IUnknown_Release( punk );
    return r;
}

static HRESULT WINAPI hnetcfg_cf_LockServer( IClassFactory *iface, BOOL dolock )
{
    FIXME("(%p)->(%d)\n", iface, dolock);
    return S_OK;
}

static const struct IClassFactoryVtbl hnetcfg_cf_vtbl =
{
    hnetcfg_cf_QueryInterface,
    hnetcfg_cf_AddRef,
    hnetcfg_cf_Release,
    hnetcfg_cf_CreateInstance,
    hnetcfg_cf_LockServer
};

static hnetcfg_cf fw_manager_cf = { { &hnetcfg_cf_vtbl }, NetFwMgr_create };
static hnetcfg_cf fw_app_cf = { { &hnetcfg_cf_vtbl }, NetFwAuthorizedApplication_create };

BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    TRACE("(0x%p, %d, %p)\n",hInstDLL,fdwReason,lpvReserved);

    switch(fdwReason) {
        case DLL_WINE_PREATTACH:
            return FALSE;
        case DLL_PROCESS_ATTACH:
            instance = hInstDLL;
            DisableThreadLibraryCalls(hInstDLL);
            break;
    }
    return TRUE;
}

HRESULT WINAPI DllGetClassObject( REFCLSID rclsid, REFIID iid, LPVOID *ppv )
{
    IClassFactory *cf = NULL;

    TRACE("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(iid), ppv);

    if (IsEqualGUID( rclsid, &CLSID_NetFwMgr ))
    {
       cf = &fw_manager_cf.IClassFactory_iface;
    }
    else if (IsEqualGUID( rclsid, &CLSID_NetFwAuthorizedApplication ))
    {
       cf = &fw_app_cf.IClassFactory_iface;
    }

    if (!cf) return CLASS_E_CLASSNOTAVAILABLE;
    return IClassFactory_QueryInterface( cf, iid, ppv );
}

HRESULT WINAPI DllCanUnloadNow( void )
{
    return S_FALSE;
}

/***********************************************************************
 *		DllRegisterServer (HNETCFG.@)
 */
HRESULT WINAPI DllRegisterServer(void)
{
    return __wine_register_resources( instance );
}

/***********************************************************************
 *		DllUnregisterServer (HNETCFG.@)
 */
HRESULT WINAPI DllUnregisterServer(void)
{
    return __wine_unregister_resources( instance );
}