text:
angular.module('crmApp').controller('LeadsEditCtrl',
    ['$scope', '$location', '$http','$routeParams', 'FileUploader','leads', 'PositionsFactory', 'UsersFactory',
    function ($scope, $location, $http,$routeParams, FileUploader,leads, PositionsFactory, UsersFactory) {

    $scope.title = 'Leads edit form'
    $scope.lead = {};
    $scope.leads = {};

    var usersFactory = UsersFactory.get();
    usersFactory.success(function(data) {
        $scope.usersList = data;
    });

    var positions = PositionsFactory.get();
    positions.success(function (data, status, headers, config) {
        $scope.positions = data;
    });

    $scope.$watch('formData.subtitle', function(a, b) {
        if(typeof a != "undefined") {
            $scope.positionsFiltered = $scope.positions.filter(positionFilter(a));
        } else {
            $scope.positionsFiltered = [];
        }
    });

    $scope.positionFill = function(name) {
        $scope.formData.subtitle = name;
    };

    $scope.test = [];
    $scope.tags = [];

    leads.getLead(
        $routeParams.leadId,
        function (data) {
            $scope.lead = data;

            console.log(data);
            if (!$scope.lead.state.hasOwnProperty('code'))
                $scope.lead.state = {code: 'new', name: 'New'};

            if (data.cv) {
                $scope.cv = true;
            } else {
                $scope.cv = false;
            }

            $scope.tags = data.tags;
            $scope.test = $scope.lead.contact.lastName;

            $scope.formData = {
                fullName: $scope.lead.contact.fullName,
                email: $scope.lead.contact.email,
                phone: $scope.lead.contact.phone,
                companyName: $scope.lead.contact.companyName,
                companyPosition: $scope.lead.contact.companyPosition,
                city: $scope.lead.contact.city,
                country: $scope.lead.contact.country,
                subtitle: $scope.lead.subtitle,
                linkedin: $scope.lead.contact.social.linkedin,
                goldenline: $scope.lead.contact.social.goldenline,
                facebook: $scope.lead.contact.social.facebook,
                source: $scope.lead.source.sourceName,
                recommendedBy: $scope.lead.source.recommendedBy,
                description: $scope.lead.description,
                _id: $scope.lead._id,
                tags: $scope.tags,
                state: 'New',
                owner: $scope.lead.owner
            }

        },
        function (data, status) {
            console.log(data);
            console.log(status);
        }
    );

    // create a blank object to hold our form information
    // $scope will allow this to pass between controller and view

        $scope.uploadError = false;
        $scope.cvFileUploaded = function (item, response, status, headers) {

            if(response.status == 'Error!' && response.code == 500) {
                $scope.uploadError = true;
            }

            if (!$scope.formData.files) {
                $scope.formData.files = response;
            }

        }

    $scope.uploader = new FileUploader({

        url: "/file/insert",
        alias: "userfile",
        autoUpload: true,
        onSuccessItem: $scope.cvFileUploaded
    }); // file uploader

    $scope.processUpload = function () {
        console.log('Uploading file ..');
    }

    // process the form
    $scope.processForm = function () {
        $http({
            method: 'POST',
            url: '/lead/edit',
            data: $.param($scope.formData),  // pass in data as strings
            headers: {'Content-Type': 'application/x-www-form-urlencoded'}  // set the headers so angular passing info as form data (not request payload)
        })
            .success(function (data) {
                console.log(data);
                if (data.code === 200) {
                    // if successful, bind success message to message
                    $location.path('/leads/' + data.lead_id);
                    swal({
                        title: "Good Job!",
                        text: "You've successfully added lead!",
                        type: "success",
                        confirmButtonText: "Close"
                    });
                    $scope.uploadError = false;
                    $scope.message = data.message;
                }
                else {
                    swal("Error!", 'Something went wrong', "error");
                    $scope.message = data.message;
                    //$scope.errorSuperhero = data.errors.superheroAlias;
                }
            });
    };

    $scope.saveTags = function () {
        $http({
            method: 'POST',
            url: '/lead/save_tags',
            data: {_id: $scope.lead._id, tags: $scope.tags},
            headers: {'Content-Type': 'application/json'}  // set the headers so angular passing info as form data (not request payload)
        })
            .success(function (data) {
                console.log(data);
                if (data.code === 200) {
                    $scope.message = data.message;
                }
                else {
                    swal("Error!", 'Something went wrong', "error");
                }
            });
    };

    $scope.files = [];

    $scope.loadFile = function () {
        $http.get('/file/download/' + $scope.lead._id).success(function (data) {
            $scope.files = data;
        });
    };

    $scope.loadFile();

}
]);


text:
#include "postgres.h"

#include <fcntl.h>
#include <unistd.h>
#ifdef PIN_PROCESSES
#include <sched.h>
#endif

#include "access/heapam.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/namespace.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_database.h"
#include "catalog/pg_tablespace.h"
#include "libpq/hba.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/postmaster.h"
#include "storage/backendid.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/sinval.h"
#include "storage/smgr.h"
#include "utils/acl.h"
#include "utils/flatfiles.h"
#include "utils/guc.h"
#include "utils/plancache.h"
#include "utils/portal.h"
#include "utils/relcache.h"
#include "utils/tqual.h"
#include "utils/syscache.h"

static bool FindMyDatabase(const char *name, Oid *db_id, Oid *db_tablespace);
static bool FindMyDatabaseByOid(Oid dbid, char *dbname, Oid *db_tablespace);
static void CheckMyDatabase(const char *name, bool am_superuser);
static void InitCommunication(void);
static void ShutdownPostgres(int code, Datum arg);
static bool ThereIsAtLeastOneRole(void);

/*** InitPostgres support ***/

/*
 * FindMyDatabase -- get the critical info needed to locate my database
 *
 * Find the named database in pg_database, return its database OID and the
 * OID of its default tablespace.  Return TRUE if found, FALSE if not.
 *
 * Since we are not yet up and running as a backend, we cannot look directly
 * at pg_database (we can't obtain locks nor participate in transactions).
 * So to get the info we need before starting up, we must look at the "flat
 * file" copy of pg_database that is helpfully maintained by flatfiles.c.
 * This is subject to various race conditions, so after we have the
 * transaction infrastructure started, we have to recheck the information;
 * see InitPostgres.
 */
static bool
FindMyDatabase(const char *name, Oid *db_id, Oid *db_tablespace)
{
	bool		result = false;
	char	   *filename;
	FILE	   *db_file;
	char		thisname[NAMEDATALEN];
	TransactionId db_frozenxid;

	filename = database_getflatfilename();
	db_file = AllocateFile(filename, "r");
	if (db_file == NULL)
		ereport(FATAL,
				(errcode_for_file_access(),
				 errmsg("could not open file \"%s\": %m", filename)));

	while (read_pg_database_line(db_file, thisname, db_id,
								 db_tablespace, &db_frozenxid))
	{
		if (strcmp(thisname, name) == 0)
		{
			result = true;
			break;
		}
	}

	FreeFile(db_file);
	pfree(filename);

	return result;
}

/*
 * FindMyDatabaseByOid
 *
 * As above, but the actual database Id is known.  Return its name and the
 * tablespace OID.	Return TRUE if found, FALSE if not.  The same restrictions
 * as FindMyDatabase apply.
 */
static bool
FindMyDatabaseByOid(Oid dbid, char *dbname, Oid *db_tablespace)
{
	bool		result = false;
	char	   *filename;
	FILE	   *db_file;
	Oid			db_id;
	char		thisname[NAMEDATALEN];
	TransactionId db_frozenxid;

	filename = database_getflatfilename();
	db_file = AllocateFile(filename, "r");
	if (db_file == NULL)
		ereport(FATAL,
				(errcode_for_file_access(),
				 errmsg("could not open file \"%s\": %m", filename)));

	while (read_pg_database_line(db_file, thisname, &db_id,
								 db_tablespace, &db_frozenxid))
	{
		if (dbid == db_id)
		{
			result = true;
			strlcpy(dbname, thisname, NAMEDATALEN);
			break;
		}
	}

	FreeFile(db_file);
	pfree(filename);

	return result;
}

/*
 * CheckMyDatabase -- fetch information from the pg_database entry for our DB
 */
static void
CheckMyDatabase(const char *name, bool am_superuser)
{
	HeapTuple	tup;
	Form_pg_database dbform;

	/* Fetch our real pg_database row */
	tup = SearchSysCache(DATABASEOID,
						 ObjectIdGetDatum(MyDatabaseId),
						 0, 0, 0);
	if (!HeapTupleIsValid(tup))
		elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);
	dbform = (Form_pg_database) GETSTRUCT(tup);

	/* This recheck is strictly paranoia */
	if (strcmp(name, NameStr(dbform->datname)) != 0)
		ereport(FATAL,
				(errcode(ERRCODE_UNDEFINED_DATABASE),
				 errmsg("database \"%s\" has disappeared from pg_database",
						name),
				 errdetail("Database OID %u now seems to belong to \"%s\".",
						   MyDatabaseId, NameStr(dbform->datname))));

	/*
	 * Check permissions to connect to the database.
	 *
	 * These checks are not enforced when in standalone mode, so that there is
	 * a way to recover from disabling all access to all databases, for
	 * example "UPDATE pg_database SET datallowconn = false;".
	 *
	 * We do not enforce them for the autovacuum worker processes either.
	 */
	if (IsUnderPostmaster && !IsAutoVacuumWorkerProcess())
	{
		/*
		 * Check that the database is currently allowing connections.
		 */
		if (!dbform->datallowconn)
			ereport(FATAL,
					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
			 errmsg("database \"%s\" is not currently accepting connections",
					name)));

		/*
		 * Check privilege to connect to the database.	(The am_superuser test
		 * is redundant, but since we have the flag, might as well check it
		 * and save a few cycles.)
		 */
		if (!am_superuser &&
			pg_database_aclcheck(MyDatabaseId, GetUserId(),
								 ACL_CONNECT) != ACLCHECK_OK)
			ereport(FATAL,
					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
					 errmsg("permission denied for database \"%s\"", name),
					 errdetail("User does not have CONNECT privilege.")));

		/*
		 * Check connection limit for this database.
		 *
		 * There is a race condition here --- we create our PGPROC before
		 * checking for other PGPROCs.	If two backends did this at about the
		 * same time, they might both think they were over the limit, while
		 * ideally one should succeed and one fail.  Getting that to work
		 * exactly seems more trouble than it is worth, however; instead we
		 * just document that the connection limit is approximate.
		 */
		if (dbform->datconnlimit >= 0 &&
			!am_superuser &&
			CountDBBackends(MyDatabaseId) > dbform->datconnlimit)
			ereport(FATAL,
					(errcode(ERRCODE_TOO_MANY_CONNECTIONS),
					 errmsg("too many connections for database \"%s\"",
							name)));
	}

	/*
	 * OK, we're golden.  Next to-do item is to save the encoding info out of
	 * the pg_database tuple.
	 */
	SetDatabaseEncoding(dbform->encoding);
	/* Record it as a GUC internal option, too */
	SetConfigOption("server_encoding", GetDatabaseEncodingName(),
					PGC_INTERNAL, PGC_S_OVERRIDE);
	/* If we have no other source of client_encoding, use server encoding */
	SetConfigOption("client_encoding", GetDatabaseEncodingName(),
					PGC_BACKEND, PGC_S_DEFAULT);

	/*
	 * Lastly, set up any database-specific configuration variables.
	 */
	if (IsUnderPostmaster)
	{
		Datum		datum;
		bool		isnull;

		datum = SysCacheGetAttr(DATABASEOID, tup, Anum_pg_database_datconfig,
								&isnull);
		if (!isnull)
		{
			ArrayType  *a = DatumGetArrayTypeP(datum);

			/*
			 * We process all the options at SUSET level.  We assume that the
			 * right to insert an option into pg_database was checked when it
			 * was inserted.
			 */
			ProcessGUCArray(a, PGC_SUSET, PGC_S_DATABASE, GUC_ACTION_SET);
		}
	}

	ReleaseSysCache(tup);
}

/* --------------------------------
 *		InitCommunication
 *
 *		This routine initializes stuff needed for ipc, locking, etc.
 *		it should be called something more informative.
 * --------------------------------
 */
static void
InitCommunication(void)
{
	/*
	 * initialize shared memory and semaphores appropriately.
	 */
	if (!IsUnderPostmaster)		/* postmaster already did this */
	{
		/*
		 * We're running a postgres bootstrap process or a standalone backend.
		 * Create private "shmem" and semaphores.
		 */
		CreateSharedMemoryAndSemaphores(true, 0);
	}
}

/*
 * Early initialization of a backend (either standalone or under postmaster).
 * This happens even before InitPostgres.
 *
 * If you're wondering why this is separate from InitPostgres at all:
 * the critical distinction is that this stuff has to happen before we can
 * run XLOG-related initialization, which is done before InitPostgres --- in
 * fact, for cases such as checkpoint creation processes, InitPostgres may
 * never be done at all.
 */
void
BaseInit(void)
{
	/*
	 * Attach to shared memory and semaphores, and initialize our
	 * input/output/debugging file descriptors.
	 */
	InitCommunication();
	DebugFileOpen();

	/* Do local initialization of file, storage and buffer managers */
	InitFileAccess();
	smgrinit();
	InitBufferPoolAccess();
}

/* --------------------------------
 * InitPostgres
 *		Initialize POSTGRES.
 *
 * The database can be specified by name, using the in_dbname parameter, or by
 * OID, using the dboid parameter.	In the latter case, the computed database
 * name is passed out to the caller as a palloc'ed string in out_dbname.
 *
 * In bootstrap mode no parameters are used.
 *
 * The return value indicates whether the userID is a superuser.  (That
 * can only be tested inside a transaction, so we want to do it during
 * the startup transaction rather than doing a separate one in postgres.c.)
 *
 * As of PostgreSQL 8.2, we expect InitProcess() was already called, so we
 * already have a PGPROC struct ... but it's not filled in yet.
 *
 * Note:
 *		Be very careful with the order of calls in the InitPostgres function.
 * --------------------------------
 */
bool
InitPostgres(const char *in_dbname, Oid dboid, const char *username,
			 char **out_dbname)
{
	bool		bootstrap = IsBootstrapProcessingMode();
	bool		autovacuum = IsAutoVacuumWorkerProcess();
	bool		am_superuser;
	char	   *fullpath;
	char		dbname[NAMEDATALEN];

	/*
	 * Set up the global variables holding database id and path.  But note we
	 * won't actually try to touch the database just yet.
	 *
	 * We take a shortcut in the bootstrap case, otherwise we have to look up
	 * the db name in pg_database.
	 */
	if (bootstrap)
	{
		MyDatabaseId = TemplateDbOid;
		MyDatabaseTableSpace = DEFAULTTABLESPACE_OID;
	}
	else
	{
		/*
		 * Find tablespace of the database we're about to open. Since we're
		 * not yet up and running we have to use one of the hackish
		 * FindMyDatabase variants, which look in the flat-file copy of
		 * pg_database.
		 *
		 * If the in_dbname param is NULL, lookup database by OID.
		 */
		if (in_dbname == NULL)
		{
			if (!FindMyDatabaseByOid(dboid, dbname, &MyDatabaseTableSpace))
				ereport(FATAL,
						(errcode(ERRCODE_UNDEFINED_DATABASE),
						 errmsg("database %u does not exist", dboid)));
			MyDatabaseId = dboid;
			/* pass the database name to the caller */
			*out_dbname = pstrdup(dbname);
		}
		else
		{
			if (!FindMyDatabase(in_dbname, &MyDatabaseId, &MyDatabaseTableSpace))
				ereport(FATAL,
						(errcode(ERRCODE_UNDEFINED_DATABASE),
						 errmsg("database \"%s\" does not exist",
								in_dbname)));
			/* our database name is gotten from the caller */
			strlcpy(dbname, in_dbname, NAMEDATALEN);
		}
	}

	fullpath = GetDatabasePath(MyDatabaseId, MyDatabaseTableSpace);

	SetDatabasePath(fullpath);

	/*
	 * Finish filling in the PGPROC struct, and add it to the ProcArray. (We
	 * need to know MyDatabaseId before we can do this, since it's entered
	 * into the PGPROC struct.)
	 *
	 * Once I have done this, I am visible to other backends!
	 */
	InitProcessPhase2();

	/*
	 * Initialize my entry in the shared-invalidation manager's array of
	 * per-backend data.
	 *
	 * Sets up MyBackendId, a unique backend identifier.
	 */
	MyBackendId = InvalidBackendId;

	InitBackendSharedInvalidationState();

	if (MyBackendId > MaxBackends || MyBackendId <= 0)
		elog(FATAL, "bad backend id: %d", MyBackendId);

#ifdef PIN_PROCESSES
	{
		cpu_set_t cpuset;
		int ret, i, cpu;
		sched_getaffinity(getpid(), sizeof cpuset, &cpuset);
		for (i = 0, cpu = 0; i < MyBackendId; ++i) {
			do {
				cpu = (cpu + 1) % CPU_SETSIZE;
			} while (!CPU_ISSET(cpu, &cpuset));
		}
		CPU_ZERO(&cpuset);
		CPU_SET(cpu, &cpuset);
		if ((ret = sched_setaffinity(getpid(), sizeof cpuset, &cpuset)) < 0) {
			elog(FATAL, "sched_setaffinity failed: %d", errno);
		}
	}
#endif

	/*
	 * bufmgr needs another initialization call too
	 */
	InitBufferPoolBackend();

	/*
	 * Initialize local process's access to XLOG.  In bootstrap case we may
	 * skip this since StartupXLOG() was run instead.
	 */
	if (!bootstrap)
		InitXLOGAccess();

	/*
	 * Initialize the relation cache and the system catalog caches.  Note that
	 * no catalog access happens here; we only set up the hashtable structure.
	 * We must do this before starting a transaction because transaction abort
	 * would try to touch these hashtables.
	 */
	RelationCacheInitialize();
	InitCatalogCache();
	InitPlanCache();

	/* Initialize portal manager */
	EnablePortalManager();

	/* Initialize stats collection --- must happen before first xact */
	if (!bootstrap)
		pgstat_initialize();

	/*
	 * Set up process-exit callback to do pre-shutdown cleanup.  This has to
	 * be after we've initialized all the low-level modules like the buffer
	 * manager, because during shutdown this has to run before the low-level
	 * modules start to close down.  On the other hand, we want it in place
	 * before we begin our first transaction --- if we fail during the
	 * initialization transaction, as is entirely possible, we need the
	 * AbortTransaction call to clean up.
	 */
	on_shmem_exit(ShutdownPostgres, 0);

	/*
	 * Start a new transaction here before first access to db, and get a
	 * snapshot.  We don't have a use for the snapshot itself, but we're
	 * interested in the secondary effect that it sets RecentGlobalXmin.
	 */
	if (!bootstrap)
	{
		StartTransactionCommand();
		(void) GetTransactionSnapshot();
	}

	/*
	 * Now that we have a transaction, we can take locks.  Take a writer's
	 * lock on the database we are trying to connect to.  If there is a
	 * concurrently running DROP DATABASE on that database, this will block us
	 * until it finishes (and has updated the flat file copy of pg_database).
	 *
	 * Note that the lock is not held long, only until the end of this startup
	 * transaction.  This is OK since we are already advertising our use of
	 * the database in the PGPROC array; anyone trying a DROP DATABASE after
	 * this point will see us there.
	 *
	 * Note: use of RowExclusiveLock here is reasonable because we envision
	 * our session as being a concurrent writer of the database.  If we had a
	 * way of declaring a session as being guaranteed-read-only, we could use
	 * AccessShareLock for such sessions and thereby not conflict against
	 * CREATE DATABASE.
	 */
	if (!bootstrap)
		LockSharedObject(DatabaseRelationId, MyDatabaseId, 0,
						 RowExclusiveLock);

	/*
	 * Recheck the flat file copy of pg_database to make sure the target
	 * database hasn't gone away.  If there was a concurrent DROP DATABASE,
	 * this ensures we will die cleanly without creating a mess.
	 */
	if (!bootstrap)
	{
		Oid			dbid2;
		Oid			tsid2;

		if (!FindMyDatabase(dbname, &dbid2, &tsid2) ||
			dbid2 != MyDatabaseId || tsid2 != MyDatabaseTableSpace)
			ereport(FATAL,
					(errcode(ERRCODE_UNDEFINED_DATABASE),
					 errmsg("database \"%s\" does not exist",
							dbname),
			   errdetail("It seems to have just been dropped or renamed.")));
	}

	/*
	 * Now we should be able to access the database directory safely. Verify
	 * it's there and looks reasonable.
	 */
	if (!bootstrap)
	{
		if (access(fullpath, F_OK) == -1)
		{
			if (errno == ENOENT)
				ereport(FATAL,
						(errcode(ERRCODE_UNDEFINED_DATABASE),
						 errmsg("database \"%s\" does not exist",
								dbname),
					errdetail("The database subdirectory \"%s\" is missing.",
							  fullpath)));
			else
				ereport(FATAL,
						(errcode_for_file_access(),
						 errmsg("could not access directory \"%s\": %m",
								fullpath)));
		}

		ValidatePgVersion(fullpath);
	}

	/*
	 * It's now possible to do real access to the system catalogs.
	 *
	 * Load relcache entries for the system catalogs.  This must create at
	 * least the minimum set of "nailed-in" cache entries.
	 */
	RelationCacheInitializePhase2();

	/*
	 * Figure out our postgres user id, and see if we are a superuser.
	 *
	 * In standalone mode and in the autovacuum process, we use a fixed id,
	 * otherwise we figure it out from the authenticated user name.
	 */
	if (bootstrap || autovacuum)
	{
		InitializeSessionUserIdStandalone();
		am_superuser = true;
	}
	else if (!IsUnderPostmaster)
	{
		InitializeSessionUserIdStandalone();
		am_superuser = true;
		if (!ThereIsAtLeastOneRole())
			ereport(WARNING,
					(errcode(ERRCODE_UNDEFINED_OBJECT),
					 errmsg("no roles are defined in this database system"),
					 errhint("You should immediately run CREATE USER \"%s\" CREATEUSER;.",
							 username)));
	}
	else
	{
		/* normal multiuser case */
		InitializeSessionUserId(username);
		am_superuser = superuser();
	}

	/* set up ACL framework (so CheckMyDatabase can check permissions) */
	initialize_acl();

	/*
	 * Read the real pg_database row for our database, check permissions and
	 * set up database-specific GUC settings.  We can't do this until all the
	 * database-access infrastructure is up.  (Also, it wants to know if the
	 * user is a superuser, so the above stuff has to happen first.)
	 */
	if (!bootstrap)
		CheckMyDatabase(dbname, am_superuser);

	/*
	 * Check a normal user hasn't connected to a superuser reserved slot.
	 */
	if (!am_superuser &&
		ReservedBackends > 0 &&
		!HaveNFreeProcs(ReservedBackends))
		ereport(FATAL,
				(errcode(ERRCODE_TOO_MANY_CONNECTIONS),
				 errmsg("connection limit exceeded for non-superusers")));

	/*
	 * Initialize various default states that can't be set up until we've
	 * selected the active user and gotten the right GUC settings.
	 */

	/* set default namespace search path */
	InitializeSearchPath();

	/* initialize client encoding */
	InitializeClientEncoding();

	/* report this backend in the PgBackendStatus array */
	if (!bootstrap)
		pgstat_bestart();

	/* close the transaction we started above */
	if (!bootstrap)
		CommitTransactionCommand();

	return am_superuser;
}

/*
 * Backend-shutdown callback.  Do cleanup that we want to be sure happens
 * before all the supporting modules begin to nail their doors shut via
 * their own callbacks.
 *
 * User-level cleanup, such as temp-relation removal and UNLISTEN, happens
 * via separate callbacks that execute before this one.  We don't combine the
 * callbacks because we still want this one to happen if the user-level
 * cleanup fails.
 */
static void
ShutdownPostgres(int code, Datum arg)
{
	/* Make sure we've killed any active transaction */
	AbortOutOfAnyTransaction();

	/*
	 * User locks are not released by transaction end, so be sure to release
	 * them explicitly.
	 */
	LockReleaseAll(USER_LOCKMETHOD, true);
}

/*
 * Returns true if at least one role is defined in this database cluster.
 */
static bool
ThereIsAtLeastOneRole(void)
{
	Relation	pg_authid_rel;
	HeapScanDesc scan;
	bool		result;

	pg_authid_rel = heap_open(AuthIdRelationId, AccessShareLock);

	scan = heap_beginscan(pg_authid_rel, SnapshotNow, 0, NULL);
	result = (heap_getnext(scan, ForwardScanDirection) != NULL);

	heap_endscan(scan);
	heap_close(pg_authid_rel, AccessShareLock);

	return result;
}

redpajama_set_name: RedPajamaGithub


text:
/**
 * @author Anton Serdyuchenko (anton415@gmail.com)
 * @version $Id$
 * @since 0.1
 */
package ru.aserdyuchenko;


text:
require File.dirname(__FILE__) + '/../../spec_helper.rb'

module Spec
  module Runner

    module ReporterSpecHelper
      def setup
        @io = StringIO.new
        @backtrace_tweaker = stub("backtrace tweaker", :tweak_backtrace => nil)
        @formatter = mock("formatter")
        @reporter = Reporter.new([@formatter], @backtrace_tweaker)
      end

      def failure
        Mocks::DuckTypeArgConstraint.new(:header, :exception)
      end
    end

    describe Reporter do
      include ReporterSpecHelper
      before(:each) {setup}

      it "should tell formatter when behaviour is added" do
        @formatter.should_receive(:add_behaviour).with("behaviour")
        @reporter.add_behaviour("behaviour")
      end

      it "should handle multiple behaviours with same name" do
        @formatter.should_receive(:add_behaviour).exactly(3).times
        @formatter.should_receive(:example_started).exactly(3).times
        @formatter.should_receive(:example_passed).exactly(3).times
        @formatter.should_receive(:start_dump)
        @formatter.should_receive(:dump_summary).with(anything(), 3, 0, 0)
        @reporter.add_behaviour("behaviour")
        @reporter.example_started("spec 1")
        @reporter.example_finished("spec 1")
        @reporter.add_behaviour("behaviour")
        @reporter.example_started("spec 2")
        @reporter.example_finished("spec 2")
        @reporter.add_behaviour("behaviour")
        @reporter.example_started("spec 3")
        @reporter.example_finished("spec 3")
        @reporter.dump
      end

      it "should handle multiple examples with the same name" do
        error=RuntimeError.new
        @formatter.should_receive(:add_behaviour).exactly(2).times
        @formatter.should_receive(:example_passed).with("example").exactly(2).times
        @formatter.should_receive(:example_failed).with("example", 1, failure)
        @formatter.should_receive(:example_failed).with("example", 2, failure)
        @formatter.should_receive(:dump_failure).exactly(2).times
        @formatter.should_receive(:start_dump)
        @formatter.should_receive(:dump_summary).with(anything(), 4, 2, 0)
        @backtrace_tweaker.should_receive(:tweak_backtrace).twice
        @reporter.add_behaviour("behaviour")
        @reporter.example_finished("example")
        @reporter.example_finished("example", error)
        @reporter.add_behaviour("behaviour")
        @reporter.example_finished("example")
        @reporter.example_finished("example", error)
        @reporter.dump
      end

      it "should push stats to formatter even with no data" do
        @formatter.should_receive(:start_dump)
        @formatter.should_receive(:dump_summary).with(anything(), 0, 0, 0)
        @reporter.dump
      end

      it "should push time to formatter" do
        @formatter.should_receive(:start).with(5)
        @formatter.should_receive(:start_dump)
        @formatter.should_receive(:dump_summary) do |time, a, b|
          time.to_s.should match(/[0-9].[0-9|e|-]+/)
        end
        @reporter.start(5)
        @reporter.end
        @reporter.dump
      end
    end

    describe Reporter, " reporting one passing example" do
      include ReporterSpecHelper
      before(:each) {setup}

      it "should tell formatter example passed" do
        @formatter.should_receive(:example_passed)
        @reporter.example_finished("example")
      end

      it "should not delegate to backtrace tweaker" do
        @formatter.should_receive(:example_passed)
        @backtrace_tweaker.should_not_receive(:tweak_backtrace)
        @reporter.example_finished("example")
      end

      it "should account for passing example in stats" do
        @formatter.should_receive(:example_passed)
        @formatter.should_receive(:start_dump)
        @formatter.should_receive(:dump_summary).with(anything(), 1, 0, 0)
        @reporter.example_finished("example")
        @reporter.dump
      end
    end

    describe Reporter, " reporting one failing example" do
      include ReporterSpecHelper
      before(:each) {setup}

      it "should tell formatter that example failed" do
        @formatter.should_receive(:example_failed)
        @reporter.example_finished("example", RuntimeError.new)
      end

      it "should delegate to backtrace tweaker" do
        @formatter.should_receive(:example_failed)
        @backtrace_tweaker.should_receive(:tweak_backtrace)
        @reporter.example_finished("spec", RuntimeError.new)
      end

      it "should account for failing example in stats" do
        @formatter.should_receive(:add_behaviour)
        @formatter.should_receive(:example_failed).with("example", 1, failure)
        @formatter.should_receive(:start_dump)
        @formatter.should_receive(:dump_failure).with(1, anything())
        @formatter.should_receive(:dump_summary).with(anything(), 1, 1, 0)
        @reporter.add_behaviour("behaviour")
        @reporter.example_finished("example", RuntimeError.new)
        @reporter.dump
      end

    end

    describe Reporter, " reporting one not implemented example" do
      include ReporterSpecHelper
      before(:each) {setup}

      it "should tell formatter example passed" do
        @formatter.should_receive(:example_not_implemented)
        @reporter.example_finished("example", nil, nil, true)
      end

      it "should account for not implemented example in stats" do
        @formatter.should_receive(:example_not_implemented)
        @formatter.should_receive(:start_dump)
        @formatter.should_receive(:dump_summary).with(anything(), 1, 0, 1)
        @reporter.example_finished("example", nil, nil, true)
        @reporter.dump
      end
    end
  end
end


text:
unless Factory.factories.keys.include?(:user)
  Factory.define(:user) do |f|
    f.email { Faker::Internet.email }
    f.password "spree123"
    f.password_confirmation "spree123"
  end
end

Factory.define(:admin_user, :parent => :user) do |u|
  u.roles { [Role.find_by_name("admin") || Factory(:role, :name => "admin")]}
end

Factory.sequence :login do |n|
  Faker::Internet.user_name + n.to_s
end


text:
#ifndef __ASM_PARAVIRT_H
#define __ASM_PARAVIRT_H
#endif


text:
using System;

namespace EventFlow.TestHelpers.Installer
{
    public class SoftwareDescription
    {
        public static SoftwareDescription Create(
            string shortName,
            Version version,
            Uri downloadUri)
        {
            return new SoftwareDescription(shortName, version, downloadUri);
        }

        public static SoftwareDescription Create(
            string shortName,
            Version version,
            string downloadUri)
        {
            return Create(shortName, version, new Uri(downloadUri, UriKind.Absolute));
        }

        public string ShortName { get; }
        public Version Version { get; }
        public Uri DownloadUri { get; }

        private SoftwareDescription(
            string shortName,
            Version version,
            Uri downloadUri)
        {
            if (string.IsNullOrEmpty(shortName)) throw new ArgumentNullException(nameof(shortName));
            if (version == null) throw new ArgumentNullException(nameof(version));
            if (downloadUri == null) throw new ArgumentNullException(nameof(downloadUri));
            if (!downloadUri.IsAbsoluteUri) throw new ArgumentException($"'{downloadUri.OriginalString}' is not absolute");

            ShortName = shortName;
            Version = version;
            DownloadUri = downloadUri;
        }

        public override string ToString()
        {
            return $"{ShortName} v{Version}";
        }
    }
}


text:
<?php

namespace Bit2Bit\OfferBundle\Enum;
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 * Description of Type
 *
 * @author Paweł
 */
class Type {
    const FLAT = 'flat';
    const HOUSE = 'house';
    const PLOT = 'plot';
    const LOCALE = 'locale';

    static function getList(){
        return array(
            self::FLAT => 'Mieszkanie',
            self::HOUSE => 'Dom',
            self::PLOT => 'Działka',
            self::LOCALE => 'Lokal'
        );
    }
}


text:
package org.spongepowered.common.mixin.tracker.world.level.block;

import net.minecraft.core.BlockPos;
import net.minecraft.core.Registry;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelAccessor;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.common.bridge.RegistryBackedTrackableBridge;
import org.spongepowered.common.bridge.world.level.block.TrackableBlockBridge;
import org.spongepowered.common.config.SpongeGameConfigs;
import org.spongepowered.common.config.tracker.TrackerCategory;
import org.spongepowered.common.event.tracking.PhaseContext;
import org.spongepowered.common.event.tracking.PhaseTracker;
import org.spongepowered.common.event.tracking.context.transaction.EffectTransactor;
import org.spongepowered.common.util.ReflectionUtil;

@Mixin(Block.class)
public abstract class BlockMixin_Tracker implements TrackableBlockBridge, RegistryBackedTrackableBridge<Block> {

    private final boolean tracker$hasNeighborLogicOverridden = ReflectionUtil.isNeighborChangedDeclared(this.getClass());
    private final boolean tracker$hasEntityInsideLogicOverridden = ReflectionUtil.isEntityInsideDeclared(this.getClass());

    @Nullable private static EffectTransactor tracker$effectTransactorForDrops = null;

    @Override
    public boolean bridge$overridesNeighborNotificationLogic() {
        return this.tracker$hasNeighborLogicOverridden;
    }

    @Override
    public boolean bridge$hasEntityInsideLogic() {
        return this.tracker$hasEntityInsideLogicOverridden;
    }

    /**
     * This is a scattering approach to checking that all block spawns being
     * attempted are going to be prevented if the block changes are currently
     * restoring.
     *
     * @author gabizou - August 16th, 2020 - Minecraft 1.14.4
     * @param ci The callback info
     */
    @Inject(
        method = {
            "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;)V",
            "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/LevelAccessor;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/entity/BlockEntity;)V",
            "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/entity/BlockEntity;Lnet/minecraft/world/entity/Entity;Lnet/minecraft/world/item/ItemStack;)V"
        },
        at = @At("HEAD"),
        cancellable = true
    )
    private static void tracker$cancelOnBlockRestoration(final CallbackInfo ci) {
        if (Thread.currentThread() == PhaseTracker.SERVER.getSidedThread()) {
            if (PhaseTracker.SERVER.getPhaseContext().isRestoring()) {
                ci.cancel();
            }
        }
    }

    @Inject(
        method = "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;)V",
        at = @At("HEAD")
    )
    private static void tracker$captureBlockProposedToBeSpawningDrops(final BlockState state, final Level worldIn,
        final BlockPos pos, final CallbackInfo ci) {
        final PhaseTracker server = PhaseTracker.SERVER;
        if (server.getSidedThread() != Thread.currentThread()) {
            return;
        }
        final PhaseContext<@NonNull ?> context = server.getPhaseContext();
        BlockMixin_Tracker.tracker$effectTransactorForDrops = context.getTransactor()
            .logBlockDrops(worldIn, pos, state, null);
    }

    @Inject(
        method = "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/LevelAccessor;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/entity/BlockEntity;)V",
        at = @At("HEAD")
    )
    private static void tracker$captureBlockProposedToBeSpawningDrops(
        final BlockState state, final LevelAccessor worldIn,
        final BlockPos pos, final @Nullable BlockEntity tileEntity, final CallbackInfo ci
    ) {
        if (!(worldIn instanceof Level)) {
            return; // In the name of my father, and his father before him, I cast you out!
        }
        final PhaseTracker server = PhaseTracker.SERVER;
        if (server.getSidedThread() != Thread.currentThread()) {
            return;
        }
        final PhaseContext<@NonNull ?> context = server.getPhaseContext();
        BlockMixin_Tracker.tracker$effectTransactorForDrops = context.getTransactor()
            .logBlockDrops((Level) worldIn, pos, state, tileEntity);
    }

    @Inject(
        method = "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/entity/BlockEntity;Lnet/minecraft/world/entity/Entity;Lnet/minecraft/world/item/ItemStack;)V",
        at = @At("HEAD")
    )
    private static void tracker$captureBlockProposedToBeSpawningDrops(final BlockState state, final Level worldIn,
        final BlockPos pos, final @Nullable BlockEntity tileEntity, final Entity entity, final ItemStack itemStack,
        final CallbackInfo ci) {
        final PhaseTracker server = PhaseTracker.SERVER;
        if (server.getSidedThread() != Thread.currentThread()) {
            return;
        }
        final PhaseContext<@NonNull ?> context = server.getPhaseContext();
        BlockMixin_Tracker.tracker$effectTransactorForDrops = context.getTransactor()
            .logBlockDrops(worldIn, pos, state, tileEntity);
    }

    @Inject(
        method = {
            "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;)V",
            "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/LevelAccessor;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/entity/BlockEntity;)V",
            "dropResources(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/entity/BlockEntity;Lnet/minecraft/world/entity/Entity;Lnet/minecraft/world/item/ItemStack;)V"
        },
        at = @At("TAIL")
    )
    private static void tracker$closeEffectIfCapturing(final CallbackInfo ci) {
        final PhaseTracker server = PhaseTracker.SERVER;
        if (server.getSidedThread() != Thread.currentThread()) {
            return;
        }
        final PhaseContext<@NonNull ?> context = server.getPhaseContext();
        context.getTransactor().completeBlockDrops(BlockMixin_Tracker.tracker$effectTransactorForDrops);
    }

    @Override
    public TrackerCategory bridge$trackerCategory() {
        return SpongeGameConfigs.getTracker().get().block;
    }

    @Override
    public Registry<Block> bridge$trackerRegistryBacking() {
        return Registry.BLOCK;
    }

    @Override
    public void bridge$saveTrackerConfig() {
        SpongeGameConfigs.getTracker().save();
    }
}


text:
Judge::Judge(){
  m_players_count = 0;
}

Judge::~Judge(){

}

void Judge::on(const Player* player){
  m_players[m_players_count++] = player;
}

void Judge::call(Player::Role role){
  switch(role){
     case Player::Villager: std::cout << "Calling: Villager" << std::endl; break;
     case Player::Werewolf: std::cout << "Calling: Werewolf" << std::endl; break;
     case Player::Seer: std::cout << "Calling: Seer" << std::endl; break;
     case Player::Witch: std::cout << "Calling: Witch" << std::endl; break;
     case Player::Hunter: std::cout << "Calling: Hunter" << std::endl; break;
   }
  for(int i = 0; i < m_players_count; i++){
     if(m_players[i]->role() == role)
           m_players[i]->answer();
     else if(role == Player::Villager)
           m_players[i]->pretend();
   }
}


text:
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}

module Main where

import Control.Monad
import qualified Data.List as List
import Data.Monoid
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Text (Text)
import qualified Data.Text as Text
import qualified Data.Text.IO as Text
import qualified Data.XML.Types as XML
import Options.Applicative
import qualified System.FilePath.Find as Find
import qualified System.Directory as Dir
import XmlEvents
import XmlInfer
import XmlParse

data ShowIgnored = ShowIgnored | ShowElements
data ShowErrors = ShowErrors | SkipErrors
data SortSetting = SortByElementName | SortByAncestor
data Verbose = Verbose | NotVerbose
data Settings = Settings
  { getFilePath :: FilePath
  , getInclude :: String
  , getExclude :: String
  , getVerbose :: Verbose
  , getShowIgnored :: ShowIgnored
  , getShowErrors :: ShowErrors
  , getSortSetting :: SortSetting
  , getLocationCount :: Int
  , getAncestorCount :: Int
  , getChildInstanceCount :: Int
  , getChildSetCount :: Int
  }

newtype Indent = Indent { getIndent :: Int }

settings :: Parser Settings
settings = Settings
  <$> strArgument
    ( metavar "PATH"
    <> help "Path to an XML file or directory of XML files"
    )
  <*> strOption
    ( long "include"
    <> short 'i'
    <> value ""
    <> metavar "INCLUDE"
    <> help "Include pattern to match files"
    )
  <*> strOption
    ( long "exclude"
    <> short 'e'
    <> value ""
    <> metavar "EXCLUDE"
    <> help "Exclude pattern to match files"
    )
  <*> flag NotVerbose Verbose
    ( long "verbose"
    <> short 'v'
    <> help "Show verbose output"
    )
  <*> flag ShowElements ShowIgnored
    ( long "show-ignored"
    <> help "Show ignored XML events"
    )
  <*> flag SkipErrors ShowErrors
    ( long "show-errors"
    <> help "Show error details for invalid XML files"
    )
  <*> flag SortByAncestor SortByElementName
    ( long "sort-by-element"
    <> help "Sort by element name"
    )
  <*> option auto
    ( long "locations"
    <> short 'l'
    <> value 0
    <> metavar "COUNT"
    <> help "Number of locations to show"
    )
  <*> option auto
    ( long "ancestors"
    <> short 'a'
    <> value 0
    <> metavar "COUNT"
    <> help "Number of ancestors to show"
    )
  <*> option auto
    ( long "child-instances"
    <> short 'c'
    <> value 0
    <> metavar "COUNT"
    <> help "Number of child instances to show"
    )
  <*> option auto
    ( long "child-sets"
    <> short 'C'
    <> value 0
    <> metavar "COUNT"
    <> help "Number of child sets to show"
    )

isVerbose :: Verbose -> Bool
isVerbose Verbose = True
isVerbose NotVerbose = False

printPerLine :: (Show a) => [a] -> IO ()
printPerLine = mapM_ print

noIndent :: Indent
noIndent = Indent 0

increaseIndent :: Indent -> Indent
increaseIndent (Indent i) = Indent (i + 1)

singleIndent :: Indent
singleIndent = increaseIndent noIndent

showIndent :: Indent -> Text
showIndent (Indent i) = Text.replicate i "  "

showName :: XML.Name -> Text
showName (XML.Name ln _ Nothing) = ln
showName (XML.Name ln _ (Just p)) = Text.concat [p, ":", ln]

textShow :: (Show a) => a -> Text
textShow = Text.pack . show

showElementName :: XML.Name -> Text
showElementName x = Text.concat ["<", showName x, ">"]

showChild :: Child -> Text
showChild (XmlInfer.Element n) = showElementName n
showChild (XmlInfer.Attribute n) = Text.concat [showName n, "=\"…\""]
showChild x = textShow x

showLocation :: Location -> Text
showLocation (Location src p) = Text.concat [Text.pack src, ":", textShow p]

showAncestors :: Ancestors -> Text
showAncestors (Ancestors []) = "(root)"
showAncestors (Ancestors ns@(_ : _)) = Text.concat . List.intersperse " " . fmap showElementName . reverse $ ns

showChildSet :: Set Child -> Text
showChildSet s =
  if Set.null s
  then "(empty)"
  else Text.concat . List.intersperse ", " . fmap showChild . Set.toList $ s

printWithIndent :: Indent -> Text -> IO ()
printWithIndent i t = Text.putStrLn $ Text.concat [showIndent i, t]

printSummary :: Indent -> Text -> Summary -> IO ()
printSummary indent label s = do
  printWithIndent indent $ Text.concat [label, ": ", textShow . locationCount $ s]
  mapM_ (printWithIndent (increaseIndent indent) . showLocation) (initialLocations s)

printMapInfo :: (Ord k) => Text -> (k -> Text) -> Map k Summary -> IO ()
printMapInfo label showKey m = do
  printWithIndent singleIndent $ Text.concat [label, ":"]
  mapM_ (\(k, ls) -> printSummary (increaseIndent singleIndent) (showKey k) ls) (Map.assocs m)

printElementInfo :: (XML.Name, ElementSummary) -> IO ()
printElementInfo (n, i) = do
  Text.putStrLn $ showElementName n
  printSummary singleIndent "locations" (locations i)
  printMapInfo "ancestors" showAncestors (ancestors i)
  printMapInfo "child instances" showChild (childInstances i)
  printMapInfo "child sets" showChildSet (childSets i)

printAnalysis :: Settings -> Map XML.Name ElementSummary -> IO ()
printAnalysis s m = do
  let
    getSortKey (n, i) = case getSortSetting s of
      SortByAncestor -> (length . Map.keys . ancestors $ i, Map.keys . ancestors $ i, n)
      SortByElementName -> (0, [], n)
  let orderedPairs = List.sortOn getSortKey (Map.assocs m)
  mapM_ printElementInfo orderedPairs

data Result = Result
  { resultIgnored :: Map FilePath [Ignored]
  , resultErrors :: Map FilePath [String]
  , resultInference :: Map XML.Name ElementSummary
  }

emptyResult :: Result
emptyResult = Result mempty mempty mempty

appendResult :: SummaryLimit -> Result -> Result -> Result
appendResult s (Result x1 y1 z1) (Result x2 y2 z2) = Result (mappend x1 x2) (mappend y1 y2) (mergeElementMap s z1 z2)

getLimits :: Settings -> SummaryLimit
getLimits s = SummaryLimit
  { limitLocations = getLocationCount s
  , limitAncestors = getAncestorCount s
  , limitChildInstances = getChildInstanceCount s
  , limitChildSets = getChildSetCount s
  }

getResult :: Settings -> FilePath -> IO Result
getResult s p = do
  when (isVerbose . getVerbose $ s) . printWithIndent singleIndent . Text.pack $ p
  (ignored, events) <- readEvents p
  let smap = Map.singleton p
  let
    (errors, inference) = case parseElementEvents events of
      Left es -> (smap es, mempty)
      Right x -> (mempty, infer (getLimits s) x)
  return $ Result (smap ignored) errors inference

getGlobNames :: Settings -> IO [FilePath]
getGlobNames s = do
  let includeInput = getInclude s
  let include = if null includeInput then "*.xml" else includeInput
  let includeMatch = Find.fileName Find.~~? include

  let exclude = getExclude s
  let excludeMatch = if null exclude then Find.always else Find.fileName Find./~? exclude
  let match = includeMatch Find.&&? excludeMatch

  names <- Find.find Find.always match (getFilePath s)
  return names

getNames :: Settings -> IO [FilePath]
getNames s = do
  let path = getFilePath s
  fileExists <- Dir.doesFileExist path
  dirExists <- Dir.doesDirectoryExist path

  if fileExists then
    return [path]
  else if dirExists then
    getGlobNames s
  else do
    Text.putStrLn "Path doesn't exist"
    return []

isSignificantIgnored :: Ignored -> Bool
isSignificantIgnored (IgnoredBeginDocument _) = False
isSignificantIgnored (IgnoredEndDocument _) = False
isSignificantIgnored (IgnoredBeginDoctype _ _ _) = True
isSignificantIgnored (IgnoredEndDoctype _) = False
isSignificantIgnored (IgnoredInstruction _ _) = True
isSignificantIgnored (IgnoredComment _ _) = True
isSignificantIgnored (IgnoredMissingPosition _ _) = False

printFileSummary :: Text -> (Ignored -> Bool) -> Map FilePath [Ignored] -> IO ()
printFileSummary label f m = do
  let ignored = Map.filter (not . null) . fmap (List.filter f) $ m
  when (not . Map.null $ ignored) $ do
    let elementCount = textShow . length . List.concat . Map.elems $ ignored
    let fileCount = textShow . length . Map.keys $ ignored
    Text.putStrLn $ Text.concat ["Ignored ", elementCount, " ", label, " in ", fileCount, " files"]

printIgnoredSummary :: Map FilePath [Ignored] -> IO ()
printIgnoredSummary ignored = do
  printFileSummary "comments" (\x -> case x of { IgnoredComment _ _ -> True; _ -> False }) ignored
  printFileSummary "doctypes" (\x -> case x of { IgnoredBeginDoctype _ _ _ -> True; _ -> False }) ignored
  printFileSummary "instructions" (\x -> case x of { IgnoredInstruction _ _ -> True; _ -> False }) ignored

readXml :: Settings -> IO ()
readXml s = do
  names <- getNames s
  Text.putStrLn $ Text.concat ["Loading ", textShow . length $ names, " files…"]

  (Result ignored errors inference) <- fmap (foldr (appendResult (getLimits s)) emptyResult) . mapM (getResult s) $ names

  let sigIgnored = Map.filter (not . null) . fmap (List.filter isSignificantIgnored) $ ignored
  when (not . Map.null $ sigIgnored) (printIgnoredSummary sigIgnored)

  let errorFilePaths = Map.keys errors
  let hasErrors = not . null $ errorFilePaths
  when hasErrors $ do
    Text.putStrLn $ Text.concat ["Errors in ", textShow . length $ errorFilePaths, " files"]
    mapM_ (printWithIndent singleIndent . Text.pack) errorFilePaths

  case getShowIgnored s of
    ShowIgnored -> printPerLine (Map.elems sigIgnored)
    ShowElements -> do
      case (hasErrors, getShowErrors s) of
        (True, ShowErrors) -> printPerLine $ Map.elems errors
        _ -> printAnalysis s inference

main :: IO ()
main = execParser opts >>= readXml
  where
  opts = info (helper <*> settings)
    ( fullDesc
    <> progDesc "Print a simple schema for XML documents"
    <> header "xml-infer - Investigate the structure of XML documents" )


text:
package talecraft.client.gui.qad;

import java.util.List;

import talecraft.util.Vec2i;

/*
	(Abstract interface for declaring layout managers)

	A layout-manager is a class that lays out the component within a container,
	according to coded in rules and parameters given to the layout-manager.
*/
public interface QADLayoutManager {

	public void layout(QADComponentContainer container, List<QADComponent> components,Vec2i newContainerSize);

}


text:
import { Ng2LaravelPage } from './app.po';

describe('ng2-laravel App', function() {
  let page: Ng2LaravelPage;

  beforeEach(() => {
    page = new Ng2LaravelPage();
  });

  it('should display message saying app works', () => {
    page.navigateTo();
    expect(page.getParagraphText()).toEqual('app works!');
  });
});


text:
<?php

use yii\helpers\Html;
use yii\widgets\ActiveForm;
use devgroup\dropzone\DropZone;
use yii\helpers\Url;

$form = ActiveForm::begin([
            'id' => 'document-form',
            'action' => ['document/process'],
            'enableAjaxValidation' => false,
            'method' => 'post',
            'options' => ['enctype' => 'multipart/form-data'],
        ]);
?>

Velden met een * zijn verplicht.

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

<?php
echo DropZone::widget([
    'name' => 'filename',
    'storedFiles' => [],
    'url' => 'index.php?r=document/batchupload',
    'options' => [
        'maxFilesize' => '2000',
        'dictDefaultMessage' => 'Plaats hier het bestand dat u wilt uploaden',
        'dictFallbackMessage' => 'Uw browser wordt niet ondersteund',
        'dictInvalidFileType' => 'Dit bestands formaat wordt niet ondersteund. Converteer het a.u.b. naar PDF.',
        'dictFileTooBig' => 'Het bestand dat u probeert te uploaden is te groot.',
    ]
]);
?>

    <?= Html::submitButton('Maak aan', ['class' => 'btn btn-primary']) ?>

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


text:
package com.orionplatform.user_management.reset_password;

import com.orionplatform.core.abstraction.OrionRuntimeException;

public class CannotEnableUserAccountException extends OrionRuntimeException
{
    private static final String DefaultErrorMessage = "Cannot enable user account.";

    public CannotEnableUserAccountException()
    {
        super(DefaultErrorMessage);
    }

    public CannotEnableUserAccountException(String message)
    {
        super(message);
    }

    public CannotEnableUserAccountException(String errorMessage, Object... arguments)
    {
        super(String.format(errorMessage, arguments));
    }

    public CannotEnableUserAccountException(Throwable cause, String errorMessage, Object... arguments)
    {
        super(String.format(errorMessage, arguments), cause);
    }

    public CannotEnableUserAccountException(Throwable cause)
    {
        super(cause, DefaultErrorMessage);
    }
}


text:
var restify = require('restify');
var builder = require('botbuilder');

// Levantar restify
var server = restify.createServer();
server.listen(process.env.port || process.env.PORT || 3978, function () {
    console.log('%s listening to %s', server.name, server.url);
});

// No te preocupes por estas credenciales por ahora, luego las usaremos para conectar los canales.
var connector = new builder.ChatConnector({
    appId: '',
    appPassword: ''
});

// Ahora utilizamos un UniversalBot
var bot = new builder.UniversalBot(connector);
server.post('/api/messages', connector.listen());

// Dialogos
bot.dialog('/', [
    function (session) {
        var msg = new builder.Message(session)
            .text("Hola! Elige una opción.")
            .suggestedActions([
                builder.CardAction.imBack(session, "productId=1&color=green", "Green"),
                builder.CardAction.imBack(session, "productId=1&color=blue", "Blue"),
                builder.CardAction.imBack(session, "productId=1&color=red", "Red")
            ]);
        session.send(msg);
    },
    function (session, results) {
        let msj = results.response;
        session.send(`Hola ${msj}!`);
    }
]);