text:
package backend.pass;

import backend.analysis.LoopInfo;
import backend.passManaging.*;
import backend.support.PrintLoopPass;
import backend.value.Loop;
import tools.Util;

import java.io.PrintStream;

/**
 * @author Jianping Zeng
 * @version 0.4
 */
public interface LoopPass extends Pass {
  @Override
  default void getAnalysisUsage(AnalysisUsage au) {
    au.addRequired(LoopInfo.class);
  }

  boolean runOnLoop(Loop loop, LPPassManager ppm);

  default boolean doInitialization(Loop loop, LPPassManager ppm) {
    return false;
  }

  default boolean doFinalization() {
    return false;
  }

  @Override
  default PassManagerType getPotentialPassManagerType() {
    return PassManagerType.PMT_LoopPassManager;
  }

  @Override
  default void assignPassManager(PMStack pms,
                                 PassManagerType pmt) {
    while (!pms.isEmpty()) {
      if (pms.peek().getPassManagerType().compareTo(PassManagerType.PMT_LoopPassManager) > 0) {
        pms.pop();
      } else
        break;
    }
    Util.assertion(!pms.isEmpty(), "Errorous status");
    LPPassManager lpm;
    if (!(pms.peek() instanceof FPPassManager)) {
      PMDataManager pmd = pms.peek();
      // Step#1 create new Function Pass Manager
      lpm = new LPPassManager(pmd.getDepth() + 1);
      lpm.populateInheritedAnalysis(pms);

      // Step#2 Assign manager to manage this new manager.
      lpm.assignPassManager(pms, pmd.getPassManagerType());
      // Step#3 Push new manager into stack.
      pms.push(lpm);
    }
    lpm = (LPPassManager) pms.peek();
    lpm.add(this);
  }

  @Override
  default void assignPassManager(PMStack pms) {
    assignPassManager(pms, PassManagerType.PMT_LoopPassManager);
  }

  @Override
  default Pass createPrinterPass(PrintStream os, String banner) {
    return PrintLoopPass.createPrintLoopPass(os, banner);
  }
}


text:
'use strict';

module.exports = function(grunt) {

  // Project configuration.
  grunt.initConfig({
    jshint: {
      all: [
        'Gruntfile.js',
        'tasks/*.js',
        '<%= nodeunit.tests %>',
      ],
      options: {
        jshintrc: '.jshintrc',
      },
    },

    // Before generating any new files, remove any previously-created files.
    clean: {
      tests: ['tmp'],
    },

    // Configuration to be run (and then tested).
    config_replace_var: {
      credentials: {
        options: {
        },
        src: [
          './test/fixtures/credentials.php.tpl'
        ],
      },
    },

    // Unit tests.
    nodeunit: {
      tests: ['test/*_test.js'],
    },

  });

  // Actually load this plugin's task(s).
  grunt.loadTasks('tasks');

  // These plugins provide necessary tasks.
  grunt.loadNpmTasks('grunt-contrib-jshint');
  grunt.loadNpmTasks('grunt-contrib-clean');
  grunt.loadNpmTasks('grunt-contrib-nodeunit');
  // Whenever the "test" task is run, first clean the "tmp" dir, then run this
  // plugin's task(s), then test the result.
  grunt.registerTask('test', ['clean', 'config_replace_var', 'nodeunit']);

  // By default, lint and run all tests.
  grunt.registerTask('default', ['jshint', 'test']);

  grunt.registerTask('do', 'Go', function () {
    grunt.task.run(['config_replace_var']);
  })

};

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Smellyriver.TankInspector.Pro.Data.Entities
{
    public static class ShellTypeHelper
    {
        public const string HEXmlName = "HIGH_EXPLOSIVE";
        public const string PremiumHEXmlName = "HIGH_EXPLOSIVE_PREMIUM";
        public const string HEATXmlName = "HOLLOW_CHARGE";
        public const string APXmlName = "ARMOR_PIERCING";
        public const string APHEXmlName = "ARMOR_PIERCING_HE";
        public const string APCRXmlName = "ARMOR_PIERCING_CR";

        public static ShellType FromXmlValue(string xmlValue)
        {

            switch (xmlValue)
            {
                case ShellTypeHelper.HEXmlName:
                    return ShellType.HE;
                case ShellTypeHelper.PremiumHEXmlName:
                    return ShellType.PremiumHE;
                case ShellTypeHelper.HEATXmlName:
                    return ShellType.HEAT;
                case ShellTypeHelper.APXmlName:
                    return ShellType.AP;
                case ShellTypeHelper.APHEXmlName:
                    return ShellType.APHE;
                case ShellTypeHelper.APCRXmlName:
                    return ShellType.APCR;
                default:
                    throw new NotSupportedException();
            }
        }
    }
}


text:
!function ( $ ) {

  "use strict"

  /* SCROLLSPY CLASS DEFINITION
   * ========================== */

  function ScrollSpy( element ) {
    var process = $.proxy(this.process, this)

    this.$scrollElement = $(element).on('scroll.scroll.data-api', process)
    this.selector = (this.$scrollElement.attr('data-target')
      || this.$scrollElement.attr('href')
      || '') + ' .nav li > a'
    this.$body = $('body').on('click.scroll.data-api', this.selector, process)

    this.refresh()
    this.process()
  }

  ScrollSpy.prototype = {

      constructor: ScrollSpy

    , refresh: function () {
        this.targets = this.$body
          .find(this.selector)
          .map(function () {
            var href = $(this).attr('href')
            return /^#\w/.test(href) && $(href).length ? href : null
          })

        this.offsets = $.map(this.targets, function (id) {
          return $(id).position().top
        })
      }

    , process: function () {
        var scrollTop = this.$scrollElement.scrollTop() + 10
          , offsets = this.offsets
          , targets = this.targets
          , activeTarget = this.activeTarget
          , i

        for (i = offsets.length; i--;) {
          activeTarget != targets[i]
            && scrollTop >= offsets[i]
            && (!offsets[i + 1] || scrollTop <= offsets[i + 1])
            && this.activate( targets[i] )
        }
      }

    , activate: function (target) {
        var active

        this.activeTarget = target

        this.$body
          .find(this.selector).parent('.active')
          .removeClass('active')

        active = this.$body
          .find(this.selector + '[href="' + target + '"]')
          .parent('li')
          .addClass('active')

        if ( active.parent('.dropdown-menu') )  {
          active.closest('li.dropdown').addClass('active')
        }
      }

  }

 /* SCROLLSPY PLUGIN DEFINITION
  * =========================== */

  $.fn.scrollspy = function ( option ) {
    return this.each(function () {
      var $this = $(this)
        , data = $this.data('scrollspy')
      if (!data) $this.data('scrollspy', (data = new ScrollSpy(this)))
      if (typeof option == 'string') data[option]()
    })
  }

  $.fn.scrollspy.Constructor = ScrollSpy

 /* SCROLLSPY DATA-API
  * ============== */

  $(function () { $('[data-spy="scroll"]').scrollspy() })

}( window.jQuery )


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

<layout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    >
  <data>
    <variable
        name="vm"
        type="com.grayherring.databinding.activity.addupdate.UploadVM"
        />
  </data>

  <android.support.design.widget.CoordinatorLayout

      android:layout_width="match_parent"
      android:layout_height="match_parent"
      android:fitsSystemWindows="true"
      >

    <android.support.design.widget.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:theme="@style/AppTheme.AppBarOverlay"
        >

      <android.support.v7.widget.Toolbar
          android:id="@+id/toolbar"
          android:layout_width="match_parent"
          android:layout_height="?attr/actionBarSize"
          android:background="?attr/colorPrimary"
          app:popupTheme="@style/AppTheme.PopupOverlay"
          />

    </android.support.design.widget.AppBarLayout>

    <LinearLayout
        android:id="@+id/root"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        app:layout_behavior="@string/appbar_scrolling_view_behavior"
        tools:showIn="@layout/activity_update_book"
        >

      <EditText
          android:id="@+id/book_title_textEdit"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:hint="@string/book_title_hint"
          android:text="@={vm.book.title}"
          />

      <EditText
          android:id="@+id/author_edittext"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:layout_gravity="center_horizontal"
          android:hint="@string/author_hint"
          android:text="@={vm.book.author}"
          />

      <EditText
          android:id="@+id/publisher_edittext"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:layout_gravity="center_horizontal"
          android:hint="@string/publisher_hint"
          android:text="@={vm.book.publisher}"
          />

      <EditText
          android:id="@+id/categories_edittext"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:layout_gravity="center_horizontal"
          android:hint="@string/categories_hint"
          android:text="@={vm.book.categories}"
          />

      <Button
          android:id="@+id/submit_button"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:layout_gravity="center_horizontal"
          android:onClick="@{vm::submitClicked}"
          android:text="@string/submit"
          />

    </LinearLayout>

  </android.support.design.widget.CoordinatorLayout>
</layout>


text:
/**
 * InvitationController.java
 *
 * Project: Kuravis
 *
 * @author MobileMan GmbH
 * @date 6.11.2013
 * @version 1.0
 *
 * (c) 2013 MobileMan GmbH, www.mobileman.com
 */

package com.mobileman.kuravis.core.ws.user;

import org.apache.shiro.authz.annotation.Logical;
import org.apache.shiro.authz.annotation.RequiresAuthentication;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.mobileman.kuravis.core.domain.user.Roles;
import com.mobileman.kuravis.core.services.user.InvitationService;
import com.mobileman.kuravis.core.util.ErrorUtils;
import com.mobileman.kuravis.core.util.JsonUtil;
import com.mobileman.kuravis.core.ws.AbstractHealtPlatformController;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;

/**
 * @author MobileMan GmbH
 *
 */
@Controller
public class InvitationController extends AbstractHealtPlatformController {

	@Autowired
	private InvitationService invitationService;

	/**
	 * @param id
	 * @return All users invoitations
	 */
	@RequestMapping(value="/user/invitations/{id}", method = RequestMethod.GET, produces = {JsonUtil.MEDIA_TYPE_APPLICATION_JSON})
	@ResponseBody
	@RequiresAuthentication
	@RequiresRoles(value = { Roles.USER, Roles.ADMIN }, logical = Logical.OR)
	public ResponseEntity<DBObject> getInvitations(@PathVariable String id) {
		log.info("getInvitations(" + id + ") - start");

		DBObject result = this.invitationService.findAllForUser(id);

		ResponseEntity<DBObject> response  = new ResponseEntity<DBObject>(result, HttpStatus.OK);

		log.info("getInvitations(" + id + ") - end: " + response);
		return response;
	}

	/**
	 * @param body
	 * @return send the invitation
	 */
	@RequestMapping(value="/user/invitations", method = RequestMethod.POST, produces = {JsonUtil.MEDIA_TYPE_APPLICATION_JSON})
	@ResponseBody
	@RequiresAuthentication
	@RequiresRoles(value = { Roles.USER, Roles.ADMIN }, logical = Logical.OR)
	public ResponseEntity<DBObject> sendInvitation(@RequestBody BasicDBObject body) {
		log.info("sendInvitation(" + body + ") - start");

		this.invitationService.sendInvitation((String)body.get("email"));
		ResponseEntity<DBObject> response  = new ResponseEntity<DBObject>(ErrorUtils.success(), HttpStatus.OK);

		log.info("sendInvitation() - end: " + response);
		return response;
	}

	/**
	 * User existence check
	 * @param body
	 * @return error message in case of error
	 */
	@RequestMapping(value="/user/invitations/canberegistered", method = RequestMethod.POST, produces = {JsonUtil.MEDIA_TYPE_APPLICATION_JSON})
	@ResponseBody
	public ResponseEntity<DBObject> canBeRegistered(@RequestBody BasicDBObject body) {
		log.info("canBeRegistered(" + body + ") - start");

		DBObject result = this.invitationService.inviteeData(body.getString("email"));

		ResponseEntity<DBObject> response  = new ResponseEntity<DBObject>(result, HttpStatus.OK);
		log.info("canBeRegistered(...) - end: " + response);
		return response;
	}
}


text: ;(function($, window, document, undefined) {


text:
/*
 * Developed by the TrustedBSD Project.
 *
 * Stub module that implements a NOOP for most (if not all) MAC Framework
 * policy entry points.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/acl.h>
#include <sys/conf.h>
#include <sys/extattr.h>
#include <sys/kernel.h>
#include <sys/ksem.h>
#include <sys/mount.h>
#include <sys/proc.h>
#include <sys/systm.h>
#include <sys/sysproto.h>
#include <sys/sysent.h>
#include <sys/vnode.h>
#include <sys/file.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/pipe.h>
#include <sys/sx.h>
#include <sys/sysctl.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <sys/shm.h>

#include <fs/devfs/devfs.h>

#include <net/bpfdesc.h>
#include <net/if.h>
#include <net/if_types.h>
#include <net/if_var.h>

#include <netinet/in.h>
#include <netinet/in_pcb.h>
#include <netinet/ip_var.h>

#include <vm/vm.h>

#include <security/mac/mac_policy.h>

SYSCTL_DECL(_security_mac);

SYSCTL_NODE(_security_mac, OID_AUTO, stub, CTLFLAG_RW, 0,
    "TrustedBSD mac_stub policy controls");

static int	stub_enabled = 1;
SYSCTL_INT(_security_mac_stub, OID_AUTO, enabled, CTLFLAG_RW,
    &stub_enabled, 0, "Enforce mac_stub policy");

/*
 * Policy module operations.
 */
static void
stub_destroy(struct mac_policy_conf *conf)
{

}

static void
stub_init(struct mac_policy_conf *conf)
{

}

static int
stub_syscall(struct thread *td, int call, void *arg)
{

	return (0);
}

/*
 * Label operations.
 */
static void
stub_init_label(struct label *label)
{

}

static int
stub_init_label_waitcheck(struct label *label, int flag)
{

	return (0);
}

static void
stub_destroy_label(struct label *label)
{

}

static void
stub_copy_label(struct label *src, struct label *dest)
{

}

static int
stub_externalize_label(struct label *label, char *element_name,
    struct sbuf *sb, int *claimed)
{

	return (0);
}

static int
stub_internalize_label(struct label *label, char *element_name,
    char *element_data, int *claimed)
{

	return (0);
}

/*
 * Object-specific entry point imeplementations are sorted alphabetically by
 * object type name and then by operation.
 */
static int
stub_bpfdesc_check_receive(struct bpf_d *d, struct label *dlabel,
    struct ifnet *ifp, struct label *ifplabel)
{

        return (0);
}

static void
stub_bpfdesc_create(struct ucred *cred, struct bpf_d *d,
    struct label *dlabel)
{

}

static void
stub_bpfdesc_create_mbuf(struct bpf_d *d, struct label *dlabel,
    struct mbuf *m, struct label *mlabel)
{

}

static void
stub_cred_associate_nfsd(struct ucred *cred)
{

}

static int
stub_cred_check_relabel(struct ucred *cred, struct label *newlabel)
{

	return (0);
}

static int
stub_cred_check_setaudit(struct ucred *cred, struct auditinfo *ai)
{

	return (0);
}

static int
stub_cred_check_setaudit_addr(struct ucred *cred, struct auditinfo_addr *aia)
{

	return (0);
}

static int
stub_cred_check_setauid(struct ucred *cred, uid_t auid)
{

	return (0);
}

static int
stub_cred_check_setegid(struct ucred *cred, gid_t egid)
{

	return (0);
}

static int
stub_cred_check_seteuid(struct ucred *cred, uid_t euid)
{

	return (0);
}

static int
stub_cred_check_setgid(struct ucred *cred, gid_t gid)
{

	return (0);
}

static int
stub_cred_check_setgroups(struct ucred *cred, int ngroups,
	gid_t *gidset)
{

	return (0);
}

static int
stub_cred_check_setregid(struct ucred *cred, gid_t rgid, gid_t egid)
{

	return (0);
}

static int
stub_cred_check_setresgid(struct ucred *cred, gid_t rgid, gid_t egid,
	gid_t sgid)
{

	return (0);
}

static int
stub_cred_check_setresuid(struct ucred *cred, uid_t ruid, uid_t euid,
	uid_t suid)
{

	return (0);
}

static int
stub_cred_check_setreuid(struct ucred *cred, uid_t ruid, uid_t euid)
{

	return (0);
}

static int
stub_cred_check_setuid(struct ucred *cred, uid_t uid)
{

	return (0);
}

static int
stub_cred_check_visible(struct ucred *cr1, struct ucred *cr2)
{

	return (0);
}

static void
stub_cred_create_init(struct ucred *cred)
{

}

static void
stub_cred_create_swapper(struct ucred *cred)
{

}

static void
stub_cred_relabel(struct ucred *cred, struct label *newlabel)
{

}

static void
stub_devfs_create_device(struct ucred *cred, struct mount *mp,
    struct cdev *dev, struct devfs_dirent *de, struct label *delabel)
{

}

static void
stub_devfs_create_directory(struct mount *mp, char *dirname,
    int dirnamelen, struct devfs_dirent *de, struct label *delabel)
{

}

static void
stub_devfs_create_symlink(struct ucred *cred, struct mount *mp,
    struct devfs_dirent *dd, struct label *ddlabel, struct devfs_dirent *de,
    struct label *delabel)
{

}

static void
stub_devfs_update(struct mount *mp, struct devfs_dirent *de,
    struct label *delabel, struct vnode *vp, struct label *vplabel)
{

}

static void
stub_devfs_vnode_associate(struct mount *mp, struct label *mplabel,
    struct devfs_dirent *de, struct label *delabel, struct vnode *vp,
    struct label *vplabel)
{

}

static int
stub_ifnet_check_relabel(struct ucred *cred, struct ifnet *ifp,
    struct label *ifplabel, struct label *newlabel)
{

	return (0);
}

static int
stub_ifnet_check_transmit(struct ifnet *ifp, struct label *ifplabel,
    struct mbuf *m, struct label *mlabel)
{

	return (0);
}

static void
stub_ifnet_create(struct ifnet *ifp, struct label *ifplabel)
{

}

static void
stub_ifnet_create_mbuf(struct ifnet *ifp, struct label *ifplabel,
    struct mbuf *m, struct label *mlabel)
{

}

static void
stub_ifnet_relabel(struct ucred *cred, struct ifnet *ifp,
    struct label *ifplabel, struct label *newlabel)
{

}

static int
stub_inpcb_check_deliver(struct inpcb *inp, struct label *inplabel,
    struct mbuf *m, struct label *mlabel)
{

	return (0);
}

static void
stub_inpcb_create(struct socket *so, struct label *solabel,
    struct inpcb *inp, struct label *inplabel)
{

}

static void
stub_inpcb_create_mbuf(struct inpcb *inp, struct label *inplabel,
    struct mbuf *m, struct label *mlabel)
{

}

static void
stub_inpcb_sosetlabel(struct socket *so, struct label *solabel,
    struct inpcb *inp, struct label *inplabel)
{

	SOCK_LOCK_ASSERT(so);

}

static void
stub_ip6q_create(struct mbuf *m, struct label *mlabel, struct ip6q *q6,
    struct label *q6label)
{

}

static int
stub_ip6q_match(struct mbuf *m, struct label *mlabel, struct ip6q *q6,
    struct label *q6label)
{

	return (1);
}

static void
stub_ip6q_reassemble(struct ip6q *q6, struct label *q6label, struct mbuf *m,
    struct label *mlabel)
{

}

static void
stub_ip6q_update(struct mbuf *m, struct label *mlabel, struct ip6q *q6,
    struct label *q6label)
{

}

static void
stub_ipq_create(struct mbuf *m, struct label *mlabel, struct ipq *q,
    struct label *qlabel)
{

}

static int
stub_ipq_match(struct mbuf *m, struct label *mlabel, struct ipq *q,
    struct label *qlabel)
{

	return (1);
}

static void
stub_ipq_reassemble(struct ipq *q, struct label *qlabel, struct mbuf *m,
    struct label *mlabel)
{

}

static void
stub_ipq_update(struct mbuf *m, struct label *mlabel, struct ipq *q,
    struct label *qlabel)
{

}

static int
stub_kenv_check_dump(struct ucred *cred)
{

	return (0);
}

static int
stub_kenv_check_get(struct ucred *cred, char *name)
{

	return (0);
}

static int
stub_kenv_check_set(struct ucred *cred, char *name, char *value)
{

	return (0);
}

static int
stub_kenv_check_unset(struct ucred *cred, char *name)
{

	return (0);
}

static int
stub_kld_check_load(struct ucred *cred, struct vnode *vp,
    struct label *vplabel)
{

	return (0);
}

static int
stub_kld_check_stat(struct ucred *cred)
{

	return (0);
}

static int
stub_mount_check_stat(struct ucred *cred, struct mount *mp,
    struct label *mplabel)
{

	return (0);
}

static void
stub_mount_create(struct ucred *cred, struct mount *mp,
    struct label *mplabel)
{

}

static void
stub_netatalk_aarp_send(struct ifnet *ifp, struct label *iflpabel,
    struct mbuf *m, struct label *mlabel)
{

}

static void
stub_netinet_arp_send(struct ifnet *ifp, struct label *iflpabel,
    struct mbuf *m, struct label *mlabel)
{

}

static void
stub_netinet_firewall_reply(struct mbuf *mrecv, struct label *mrecvlabel,
    struct mbuf *msend, struct label *msendlabel)
{

}

static void
stub_netinet_firewall_send(struct mbuf *m, struct label *mlabel)
{

}

static void
stub_netinet_fragment(struct mbuf *m, struct label *mlabel, struct mbuf *frag,
    struct label *fraglabel)
{

}

static void
stub_netinet_icmp_reply(struct mbuf *mrecv, struct label *mrecvlabel,
    struct mbuf *msend, struct label *msendlabel)
{

}

static void
stub_netinet_icmp_replyinplace(struct mbuf *m, struct label *mlabel)
{

}

static void
stub_netinet_igmp_send(struct ifnet *ifp, struct label *iflpabel,
    struct mbuf *m, struct label *mlabel)
{

}

static void
stub_netinet_tcp_reply(struct mbuf *m, struct label *mlabel)
{

}

static void
stub_netinet6_nd6_send(struct ifnet *ifp, struct label *iflpabel,
    struct mbuf *m, struct label *mlabel)
{

}

static int
stub_pipe_check_ioctl(struct ucred *cred, struct pipepair *pp,
    struct label *pplabel, unsigned long cmd, void /* caddr_t */ *data)
{

	return (0);
}

static int
stub_pipe_check_poll(struct ucred *cred, struct pipepair *pp,
    struct label *pplabel)
{

	return (0);
}

static int
stub_pipe_check_read(struct ucred *cred, struct pipepair *pp,
    struct label *pplabel)
{

	return (0);
}

static int
stub_pipe_check_relabel(struct ucred *cred, struct pipepair *pp,
    struct label *pplabel, struct label *newlabel)
{

	return (0);
}

static int
stub_pipe_check_stat(struct ucred *cred, struct pipepair *pp,
    struct label *pplabel)
{

	return (0);
}

static int
stub_pipe_check_write(struct ucred *cred, struct pipepair *pp,
    struct label *pplabel)
{

	return (0);
}

static void
stub_pipe_create(struct ucred *cred, struct pipepair *pp,
    struct label *pplabel)
{

}

static void
stub_pipe_relabel(struct ucred *cred, struct pipepair *pp,
    struct label *pplabel, struct label *newlabel)
{

}

static int
stub_posixsem_check_getvalue(struct ucred *active_cred, struct ucred *file_cred,
    struct ksem *ks, struct label *kslabel)
{

	return (0);
}

static int
stub_posixsem_check_open(struct ucred *cred, struct ksem *ks,
    struct label *kslabel)
{

	return (0);
}

static int
stub_posixsem_check_post(struct ucred *active_cred, struct ucred *file_cred,
    struct ksem *ks, struct label *kslabel)
{

	return (0);
}

static int
stub_posixsem_check_setmode(struct ucred *cred, struct ksem *ks,
    struct label *kslabel, mode_t mode)
{

	return (0);
}

static int
stub_posixsem_check_setowner(struct ucred *cred, struct ksem *ks,
    struct label *kslabel, uid_t uid, gid_t gid)
{

	return (0);
}

static int
stub_posixsem_check_stat(struct ucred *active_cred, struct ucred *file_cred,
    struct ksem *ks, struct label *kslabel)
{

	return (0);
}

static int
stub_posixsem_check_unlink(struct ucred *cred, struct ksem *ks,
    struct label *kslabel)
{

	return (0);
}

static int
stub_posixsem_check_wait(struct ucred *active_cred, struct ucred *file_cred,
    struct ksem *ks, struct label *kslabel)
{

	return (0);
}

static void
stub_posixsem_create(struct ucred *cred, struct ksem *ks,
    struct label *kslabel)
{

}

static int
stub_posixshm_check_create(struct ucred *cred, const char *path)
{

	return (0);
}

static int
stub_posixshm_check_mmap(struct ucred *cred, struct shmfd *shmfd,
    struct label *shmlabel, int prot, int flags)
{

	return (0);
}

static int
stub_posixshm_check_open(struct ucred *cred, struct shmfd *shmfd,
    struct label *shmlabel, accmode_t accmode)
{

	return (0);
}

static int
stub_posixshm_check_setmode(struct ucred *cred, struct shmfd *shmfd,
    struct label *shmlabel, mode_t mode)
{

	return (0);
}

static int
stub_posixshm_check_setowner(struct ucred *cred, struct shmfd *shmfd,
    struct label *shmlabel, uid_t uid, gid_t gid)
{

	return (0);
}

static int
stub_posixshm_check_stat(struct ucred *active_cred, struct ucred *file_cred,
    struct shmfd *shmfd, struct label *shmlabel)
{

	return (0);
}

static int
stub_posixshm_check_truncate(struct ucred *active_cred,
    struct ucred *file_cred, struct shmfd *shmfd, struct label *shmlabel)
{

	return (0);
}

static int
stub_posixshm_check_unlink(struct ucred *cred, struct shmfd *shmfd,
    struct label *shmlabel)
{

	return (0);
}

static void
stub_posixshm_create(struct ucred *cred, struct shmfd *shmfd,
    struct label *shmlabel)
{

}

static int
stub_priv_check(struct ucred *cred, int priv)
{

	return (0);
}

static int
stub_priv_grant(struct ucred *cred, int priv)
{

	return (EPERM);
}

static int
stub_proc_check_debug(struct ucred *cred, struct proc *p)
{

	return (0);
}

static int
stub_proc_check_sched(struct ucred *cred, struct proc *p)
{

	return (0);
}

static int
stub_proc_check_signal(struct ucred *cred, struct proc *p, int signum)
{

	return (0);
}

static int
stub_proc_check_wait(struct ucred *cred, struct proc *p)
{

	return (0);
}

static int
stub_socket_check_accept(struct ucred *cred, struct socket *so,
    struct label *solabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_socket_check_bind(struct ucred *cred, struct socket *so,
    struct label *solabel, struct sockaddr *sa)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_socket_check_connect(struct ucred *cred, struct socket *so,
    struct label *solabel, struct sockaddr *sa)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_socket_check_create(struct ucred *cred, int domain, int type, int proto)
{

	return (0);
}

static int
stub_socket_check_deliver(struct socket *so, struct label *solabel,
    struct mbuf *m, struct label *mlabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_socket_check_listen(struct ucred *cred, struct socket *so,
    struct label *solabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_socket_check_poll(struct ucred *cred, struct socket *so,
    struct label *solabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_socket_check_receive(struct ucred *cred, struct socket *so,
    struct label *solabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_socket_check_relabel(struct ucred *cred, struct socket *so,
    struct label *solabel, struct label *newlabel)
{

	SOCK_LOCK_ASSERT(so);

	return (0);
}
static int
stub_socket_check_send(struct ucred *cred, struct socket *so,
    struct label *solabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_socket_check_stat(struct ucred *cred, struct socket *so,
    struct label *solabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static int
stub_inpcb_check_visible(struct ucred *cred, struct inpcb *inp,
   struct label *inplabel)
{

	return (0);
}

static int
stub_socket_check_visible(struct ucred *cred, struct socket *so,
   struct label *solabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif

	return (0);
}

static void
stub_socket_create(struct ucred *cred, struct socket *so,
    struct label *solabel)
{

}

static void
stub_socket_create_mbuf(struct socket *so, struct label *solabel,
    struct mbuf *m, struct label *mlabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif
}

static void
stub_socket_newconn(struct socket *oldso, struct label *oldsolabel,
    struct socket *newso, struct label *newsolabel)
{

#if 0
	SOCK_LOCK(oldso);
	SOCK_UNLOCK(oldso);
#endif
#if 0
	SOCK_LOCK(newso);
	SOCK_UNLOCK(newso);
#endif
}

static void
stub_socket_relabel(struct ucred *cred, struct socket *so,
    struct label *solabel, struct label *newlabel)
{

	SOCK_LOCK_ASSERT(so);
}

static void
stub_socketpeer_set_from_mbuf(struct mbuf *m, struct label *mlabel,
    struct socket *so, struct label *sopeerlabel)
{

#if 0
	SOCK_LOCK(so);
	SOCK_UNLOCK(so);
#endif
}

static void
stub_socketpeer_set_from_socket(struct socket *oldso,
    struct label *oldsolabel, struct socket *newso,
    struct label *newsopeerlabel)
{

#if 0
	SOCK_LOCK(oldso);
	SOCK_UNLOCK(oldso);
#endif
#if 0
	SOCK_LOCK(newso);
	SOCK_UNLOCK(newso);
#endif
}

static void
stub_syncache_create(struct label *label, struct inpcb *inp)
{

}

static void
stub_syncache_create_mbuf(struct label *sc_label, struct mbuf *m,
    struct label *mlabel)
{

}

static int
stub_system_check_acct(struct ucred *cred, struct vnode *vp,
    struct label *vplabel)
{

	return (0);
}

static int
stub_system_check_audit(struct ucred *cred, void *record, int length)
{

	return (0);
}

static int
stub_system_check_auditctl(struct ucred *cred, struct vnode *vp,
    struct label *vplabel)
{

	return (0);
}

static int
stub_system_check_auditon(struct ucred *cred, int cmd)
{

	return (0);
}

static int
stub_system_check_reboot(struct ucred *cred, int how)
{

	return (0);
}

static int
stub_system_check_swapoff(struct ucred *cred, struct vnode *vp,
    struct label *vplabel)
{

	return (0);
}

static int
stub_system_check_swapon(struct ucred *cred, struct vnode *vp,
    struct label *vplabel)
{

	return (0);
}

static int
stub_system_check_sysctl(struct ucred *cred, struct sysctl_oid *oidp,
    void *arg1, int arg2, struct sysctl_req *req)
{

	return (0);
}

static void
stub_sysvmsg_cleanup(struct label *msglabel)
{

}

static void
stub_sysvmsg_create(struct ucred *cred, struct msqid_kernel *msqkptr,
    struct label *msqlabel, struct msg *msgptr, struct label *msglabel)
{

}

static int
stub_sysvmsq_check_msgmsq(struct ucred *cred, struct msg *msgptr,
    struct label *msglabel, struct msqid_kernel *msqkptr,
    struct label *msqklabel)
{

	return (0);
}

static int
stub_sysvmsq_check_msgrcv(struct ucred *cred, struct msg *msgptr,
    struct label *msglabel)
{

	return (0);
}

static int
stub_sysvmsq_check_msgrmid(struct ucred *cred, struct msg *msgptr,
    struct label *msglabel)
{

	return (0);
}

static int
stub_sysvmsq_check_msqget(struct ucred *cred, struct msqid_kernel *msqkptr,
    struct label *msqklabel)
{

	return (0);
}

static int
stub_sysvmsq_check_msqsnd(struct ucred *cred, struct msqid_kernel *msqkptr,
    struct label *msqklabel)
{

	return (0);
}

static int
stub_sysvmsq_check_msqrcv(struct ucred *cred, struct msqid_kernel *msqkptr,
    struct label *msqklabel)
{

	return (0);
}

static int
stub_sysvmsq_check_msqctl(struct ucred *cred, struct msqid_kernel *msqkptr,
    struct label *msqklabel, int cmd)
{

	return (0);
}

static void
stub_sysvmsq_cleanup(struct label *msqlabel)
{

}

static void
stub_sysvmsq_create(struct ucred *cred, struct msqid_kernel *msqkptr,
    struct label *msqlabel)
{

}

static int
stub_sysvsem_check_semctl(struct ucred *cred, struct semid_kernel *semakptr,
    struct label *semaklabel, int cmd)
{

	return (0);
}

static int
stub_sysvsem_check_semget(struct ucred *cred, struct semid_kernel *semakptr,
    struct label *semaklabel)
{

	return (0);
}

static int
stub_sysvsem_check_semop(struct ucred *cred, struct semid_kernel *semakptr,
    struct label *semaklabel, size_t accesstype)
{

	return (0);
}

static void
stub_sysvsem_cleanup(struct label *semalabel)
{

}

static void
stub_sysvsem_create(struct ucred *cred, struct semid_kernel *semakptr,
    struct label *semalabel)
{

}

static int
stub_sysvshm_check_shmat(struct ucred *cred, struct shmid_kernel *shmsegptr,
    struct label *shmseglabel, int shmflg)
{

	return (0);
}

static int
stub_sysvshm_check_shmctl(struct ucred *cred, struct shmid_kernel *shmsegptr,
    struct label *shmseglabel, int cmd)
{

	return (0);
}

static int
stub_sysvshm_check_shmdt(struct ucred *cred, struct shmid_kernel *shmsegptr,
    struct label *shmseglabel)
{

	return (0);
}

static int
stub_sysvshm_check_shmget(struct ucred *cred, struct shmid_kernel *shmsegptr,
    struct label *shmseglabel, int shmflg)
{

	return (0);
}

static void
stub_sysvshm_cleanup(struct label *shmlabel)
{

}

static void
stub_sysvshm_create(struct ucred *cred, struct shmid_kernel *shmsegptr,
    struct label *shmalabel)
{

}

static void
stub_thread_userret(struct thread *td)
{

}

static int
stub_vnode_associate_extattr(struct mount *mp, struct label *mplabel,
    struct vnode *vp, struct label *vplabel)
{

	return (0);
}

static void
stub_vnode_associate_singlelabel(struct mount *mp, struct label *mplabel,
    struct vnode *vp, struct label *vplabel)
{

}

static int
stub_vnode_check_access(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, accmode_t accmode)
{

	return (0);
}

static int
stub_vnode_check_chdir(struct ucred *cred, struct vnode *dvp,
    struct label *dvplabel)
{

	return (0);
}

static int
stub_vnode_check_chroot(struct ucred *cred, struct vnode *dvp,
    struct label *dvplabel)
{

	return (0);
}

static int
stub_vnode_check_create(struct ucred *cred, struct vnode *dvp,
    struct label *dvplabel, struct componentname *cnp, struct vattr *vap)
{

	return (0);
}

static int
stub_vnode_check_deleteacl(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, acl_type_t type)
{

	return (0);
}

static int
stub_vnode_check_deleteextattr(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, int attrnamespace, const char *name)
{

	return (0);
}

static int
stub_vnode_check_exec(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, struct image_params *imgp,
    struct label *execlabel)
{

	return (0);
}

static int
stub_vnode_check_getacl(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, acl_type_t type)
{

	return (0);
}

static int
stub_vnode_check_getextattr(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, int attrnamespace, const char *name)
{

	return (0);
}

static int
stub_vnode_check_link(struct ucred *cred, struct vnode *dvp,
    struct label *dvplabel, struct vnode *vp, struct label *vplabel,
    struct componentname *cnp)
{

	return (0);
}

static int
stub_vnode_check_listextattr(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, int attrnamespace)
{

	return (0);
}

static int
stub_vnode_check_lookup(struct ucred *cred, struct vnode *dvp,
    struct label *dvplabel, struct componentname *cnp)
{

	return (0);
}

static int
stub_vnode_check_mmap(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, int prot, int flags)
{

	return (0);
}

static void
stub_vnode_check_mmap_downgrade(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, int *prot)
{

}

static int
stub_vnode_check_mprotect(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, int prot)
{

	return (0);
}

static int
stub_vnode_check_open(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, accmode_t accmode)
{

	return (0);
}

static int
stub_vnode_check_poll(struct ucred *active_cred, struct ucred *file_cred,
    struct vnode *vp, struct label *vplabel)
{

	return (0);
}

static int
stub_vnode_check_read(struct ucred *active_cred, struct ucred *file_cred,
    struct vnode *vp, struct label *vplabel)
{

	return (0);
}

static int
stub_vnode_check_readdir(struct ucred *cred, struct vnode *vp,
    struct label *dvplabel)
{

	return (0);
}

static int
stub_vnode_check_readlink(struct ucred *cred, struct vnode *vp,
    struct label *vplabel)
{

	return (0);
}

static int
stub_vnode_check_relabel(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, struct label *newlabel)
{

	return (0);
}

static int
stub_vnode_check_rename_from(struct ucred *cred, struct vnode *dvp,
    struct label *dvplabel, struct vnode *vp, struct label *vplabel,
    struct componentname *cnp)
{

	return (0);
}

static int
stub_vnode_check_rename_to(struct ucred *cred, struct vnode *dvp,
    struct label *dvplabel, struct vnode *vp, struct label *vplabel,
    int samedir, struct componentname *cnp)
{

	return (0);
}

static int
stub_vnode_check_revoke(struct ucred *cred, struct vnode *vp,
    struct label *vplabel)
{

	return (0);
}

static int
stub_vnode_check_setacl(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, acl_type_t type, struct acl *acl)
{

	return (0);
}

static int
stub_vnode_check_setextattr(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, int attrnamespace, const char *name)
{

	return (0);
}

static int
stub_vnode_check_setflags(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, u_long flags)
{

	return (0);
}

static int
stub_vnode_check_setmode(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, mode_t mode)
{

	return (0);
}

static int
stub_vnode_check_setowner(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, uid_t uid, gid_t gid)
{

	return (0);
}

static int
stub_vnode_check_setutimes(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, struct timespec atime, struct timespec mtime)
{

	return (0);
}

static int
stub_vnode_check_stat(struct ucred *active_cred, struct ucred *file_cred,
    struct vnode *vp, struct label *vplabel)
{

	return (0);
}

static int
stub_vnode_check_unlink(struct ucred *cred, struct vnode *dvp,
    struct label *dvplabel, struct vnode *vp, struct label *vplabel,
    struct componentname *cnp)
{

	return (0);
}

static int
stub_vnode_check_write(struct ucred *active_cred, struct ucred *file_cred,
    struct vnode *vp, struct label *vplabel)
{

	return (0);
}

static int
stub_vnode_create_extattr(struct ucred *cred, struct mount *mp,
    struct label *mntlabel, struct vnode *dvp, struct label *dvplabel,
    struct vnode *vp, struct label *vplabel, struct componentname *cnp)
{

	return (0);
}

static void
stub_vnode_execve_transition(struct ucred *old, struct ucred *new,
    struct vnode *vp, struct label *vplabel, struct label *interpvplabel,
    struct image_params *imgp, struct label *execlabel)
{

}

static int
stub_vnode_execve_will_transition(struct ucred *old, struct vnode *vp,
    struct label *vplabel, struct label *interpvplabel,
    struct image_params *imgp, struct label *execlabel)
{

	return (0);
}

static void
stub_vnode_relabel(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, struct label *label)
{

}

static int
stub_vnode_setlabel_extattr(struct ucred *cred, struct vnode *vp,
    struct label *vplabel, struct label *intlabel)
{

	return (0);
}

/*
 * Register functions with MAC Framework policy entry points.
 */
static struct mac_policy_ops stub_ops =
{
	.mpo_destroy = stub_destroy,
	.mpo_init = stub_init,
	.mpo_syscall = stub_syscall,

	.mpo_bpfdesc_check_receive = stub_bpfdesc_check_receive,
	.mpo_bpfdesc_create = stub_bpfdesc_create,
	.mpo_bpfdesc_create_mbuf = stub_bpfdesc_create_mbuf,
	.mpo_bpfdesc_destroy_label = stub_destroy_label,
	.mpo_bpfdesc_init_label = stub_init_label,

	.mpo_cred_associate_nfsd = stub_cred_associate_nfsd,
	.mpo_cred_check_relabel = stub_cred_check_relabel,
	.mpo_cred_check_setaudit = stub_cred_check_setaudit,
	.mpo_cred_check_setaudit_addr = stub_cred_check_setaudit_addr,
	.mpo_cred_check_setauid = stub_cred_check_setauid,
	.mpo_cred_check_setegid = stub_cred_check_setegid,
	.mpo_cred_check_seteuid = stub_cred_check_seteuid,
	.mpo_cred_check_setgid = stub_cred_check_setgid,
	.mpo_cred_check_setgroups = stub_cred_check_setgroups,
	.mpo_cred_check_setregid = stub_cred_check_setregid,
	.mpo_cred_check_setresgid = stub_cred_check_setresgid,
	.mpo_cred_check_setresuid = stub_cred_check_setresuid,
	.mpo_cred_check_setreuid = stub_cred_check_setreuid,
	.mpo_cred_check_setuid = stub_cred_check_setuid,
	.mpo_cred_check_visible = stub_cred_check_visible,
	.mpo_cred_copy_label = stub_copy_label,
	.mpo_cred_create_init = stub_cred_create_init,
	.mpo_cred_create_swapper = stub_cred_create_swapper,
	.mpo_cred_destroy_label = stub_destroy_label,
	.mpo_cred_externalize_label = stub_externalize_label,
	.mpo_cred_init_label = stub_init_label,
	.mpo_cred_internalize_label = stub_internalize_label,
	.mpo_cred_relabel= stub_cred_relabel,

	.mpo_devfs_create_device = stub_devfs_create_device,
	.mpo_devfs_create_directory = stub_devfs_create_directory,
	.mpo_devfs_create_symlink = stub_devfs_create_symlink,
	.mpo_devfs_destroy_label = stub_destroy_label,
	.mpo_devfs_init_label = stub_init_label,
	.mpo_devfs_update = stub_devfs_update,
	.mpo_devfs_vnode_associate = stub_devfs_vnode_associate,

	.mpo_ifnet_check_relabel = stub_ifnet_check_relabel,
	.mpo_ifnet_check_transmit = stub_ifnet_check_transmit,
	.mpo_ifnet_copy_label = stub_copy_label,
	.mpo_ifnet_create = stub_ifnet_create,
	.mpo_ifnet_create_mbuf = stub_ifnet_create_mbuf,
	.mpo_ifnet_destroy_label = stub_destroy_label,
	.mpo_ifnet_externalize_label = stub_externalize_label,
	.mpo_ifnet_init_label = stub_init_label,
	.mpo_ifnet_internalize_label = stub_internalize_label,
	.mpo_ifnet_relabel = stub_ifnet_relabel,

	.mpo_inpcb_check_deliver = stub_inpcb_check_deliver,
	.mpo_inpcb_check_visible = stub_inpcb_check_visible,
	.mpo_inpcb_create = stub_inpcb_create,
	.mpo_inpcb_create_mbuf = stub_inpcb_create_mbuf,
	.mpo_inpcb_destroy_label = stub_destroy_label,
	.mpo_inpcb_init_label = stub_init_label_waitcheck,
	.mpo_inpcb_sosetlabel = stub_inpcb_sosetlabel,

	.mpo_ip6q_create = stub_ip6q_create,
	.mpo_ip6q_destroy_label = stub_destroy_label,
	.mpo_ip6q_init_label = stub_init_label_waitcheck,
	.mpo_ip6q_match = stub_ip6q_match,
	.mpo_ip6q_update = stub_ip6q_update,
	.mpo_ip6q_reassemble = stub_ip6q_reassemble,

	.mpo_ipq_create = stub_ipq_create,
	.mpo_ipq_destroy_label = stub_destroy_label,
	.mpo_ipq_init_label = stub_init_label_waitcheck,
	.mpo_ipq_match = stub_ipq_match,
	.mpo_ipq_update = stub_ipq_update,
	.mpo_ipq_reassemble = stub_ipq_reassemble,

	.mpo_kenv_check_dump = stub_kenv_check_dump,
	.mpo_kenv_check_get = stub_kenv_check_get,
	.mpo_kenv_check_set = stub_kenv_check_set,
	.mpo_kenv_check_unset = stub_kenv_check_unset,

	.mpo_kld_check_load = stub_kld_check_load,
	.mpo_kld_check_stat = stub_kld_check_stat,

	.mpo_mbuf_copy_label = stub_copy_label,
	.mpo_mbuf_destroy_label = stub_destroy_label,
	.mpo_mbuf_init_label = stub_init_label_waitcheck,

	.mpo_mount_check_stat = stub_mount_check_stat,
	.mpo_mount_create = stub_mount_create,
	.mpo_mount_destroy_label = stub_destroy_label,
	.mpo_mount_init_label = stub_init_label,

	.mpo_netatalk_aarp_send = stub_netatalk_aarp_send,

	.mpo_netinet_arp_send = stub_netinet_arp_send,
	.mpo_netinet_firewall_reply = stub_netinet_firewall_reply,
	.mpo_netinet_firewall_send = stub_netinet_firewall_send,
	.mpo_netinet_fragment = stub_netinet_fragment,
	.mpo_netinet_icmp_reply = stub_netinet_icmp_reply,
	.mpo_netinet_icmp_replyinplace = stub_netinet_icmp_replyinplace,
	.mpo_netinet_tcp_reply = stub_netinet_tcp_reply,
	.mpo_netinet_igmp_send = stub_netinet_igmp_send,

	.mpo_netinet6_nd6_send = stub_netinet6_nd6_send,

	.mpo_pipe_check_ioctl = stub_pipe_check_ioctl,
	.mpo_pipe_check_poll = stub_pipe_check_poll,
	.mpo_pipe_check_read = stub_pipe_check_read,
	.mpo_pipe_check_relabel = stub_pipe_check_relabel,
	.mpo_pipe_check_stat = stub_pipe_check_stat,
	.mpo_pipe_check_write = stub_pipe_check_write,
	.mpo_pipe_copy_label = stub_copy_label,
	.mpo_pipe_create = stub_pipe_create,
	.mpo_pipe_destroy_label = stub_destroy_label,
	.mpo_pipe_externalize_label = stub_externalize_label,
	.mpo_pipe_init_label = stub_init_label,
	.mpo_pipe_internalize_label = stub_internalize_label,
	.mpo_pipe_relabel = stub_pipe_relabel,

	.mpo_posixsem_check_getvalue = stub_posixsem_check_getvalue,
	.mpo_posixsem_check_open = stub_posixsem_check_open,
	.mpo_posixsem_check_post = stub_posixsem_check_post,
	.mpo_posixsem_check_setmode = stub_posixsem_check_setmode,
	.mpo_posixsem_check_setowner = stub_posixsem_check_setowner,
	.mpo_posixsem_check_stat = stub_posixsem_check_stat,
	.mpo_posixsem_check_unlink = stub_posixsem_check_unlink,
	.mpo_posixsem_check_wait = stub_posixsem_check_wait,
	.mpo_posixsem_create = stub_posixsem_create,
	.mpo_posixsem_destroy_label = stub_destroy_label,
	.mpo_posixsem_init_label = stub_init_label,

	.mpo_posixshm_check_create = stub_posixshm_check_create,
	.mpo_posixshm_check_mmap = stub_posixshm_check_mmap,
	.mpo_posixshm_check_open = stub_posixshm_check_open,
	.mpo_posixshm_check_setmode = stub_posixshm_check_setmode,
	.mpo_posixshm_check_setowner = stub_posixshm_check_setowner,
	.mpo_posixshm_check_stat = stub_posixshm_check_stat,
	.mpo_posixshm_check_truncate = stub_posixshm_check_truncate,
	.mpo_posixshm_check_unlink = stub_posixshm_check_unlink,
	.mpo_posixshm_create = stub_posixshm_create,
	.mpo_posixshm_destroy_label = stub_destroy_label,
	.mpo_posixshm_init_label = stub_init_label,

	.mpo_priv_check = stub_priv_check,
	.mpo_priv_grant = stub_priv_grant,

	.mpo_proc_check_debug = stub_proc_check_debug,
	.mpo_proc_check_sched = stub_proc_check_sched,
	.mpo_proc_check_signal = stub_proc_check_signal,
	.mpo_proc_check_wait = stub_proc_check_wait,

	.mpo_socket_check_accept = stub_socket_check_accept,
	.mpo_socket_check_bind = stub_socket_check_bind,
	.mpo_socket_check_connect = stub_socket_check_connect,
	.mpo_socket_check_create = stub_socket_check_create,
	.mpo_socket_check_deliver = stub_socket_check_deliver,
	.mpo_socket_check_listen = stub_socket_check_listen,
	.mpo_socket_check_poll = stub_socket_check_poll,
	.mpo_socket_check_receive = stub_socket_check_receive,
	.mpo_socket_check_relabel = stub_socket_check_relabel,
	.mpo_socket_check_send = stub_socket_check_send,
	.mpo_socket_check_stat = stub_socket_check_stat,
	.mpo_socket_check_visible = stub_socket_check_visible,
	.mpo_socket_copy_label = stub_copy_label,
	.mpo_socket_create = stub_socket_create,
	.mpo_socket_create_mbuf = stub_socket_create_mbuf,
	.mpo_socket_destroy_label = stub_destroy_label,
	.mpo_socket_externalize_label = stub_externalize_label,
	.mpo_socket_init_label = stub_init_label_waitcheck,
	.mpo_socket_internalize_label = stub_internalize_label,
	.mpo_socket_newconn = stub_socket_newconn,
	.mpo_socket_relabel = stub_socket_relabel,

	.mpo_socketpeer_destroy_label = stub_destroy_label,
	.mpo_socketpeer_externalize_label = stub_externalize_label,
	.mpo_socketpeer_init_label = stub_init_label_waitcheck,
	.mpo_socketpeer_set_from_mbuf = stub_socketpeer_set_from_mbuf,
	.mpo_socketpeer_set_from_socket = stub_socketpeer_set_from_socket,

	.mpo_syncache_init_label = stub_init_label_waitcheck,
	.mpo_syncache_destroy_label = stub_destroy_label,
	.mpo_syncache_create = stub_syncache_create,
	.mpo_syncache_create_mbuf= stub_syncache_create_mbuf,

	.mpo_sysvmsg_cleanup = stub_sysvmsg_cleanup,
	.mpo_sysvmsg_create = stub_sysvmsg_create,
	.mpo_sysvmsg_destroy_label = stub_destroy_label,
	.mpo_sysvmsg_init_label = stub_init_label,

	.mpo_sysvmsq_check_msgmsq = stub_sysvmsq_check_msgmsq,
	.mpo_sysvmsq_check_msgrcv = stub_sysvmsq_check_msgrcv,
	.mpo_sysvmsq_check_msgrmid = stub_sysvmsq_check_msgrmid,
	.mpo_sysvmsq_check_msqget = stub_sysvmsq_check_msqget,
	.mpo_sysvmsq_check_msqsnd = stub_sysvmsq_check_msqsnd,
	.mpo_sysvmsq_check_msqrcv = stub_sysvmsq_check_msqrcv,
	.mpo_sysvmsq_check_msqctl = stub_sysvmsq_check_msqctl,
	.mpo_sysvmsq_cleanup = stub_sysvmsq_cleanup,
	.mpo_sysvmsq_create = stub_sysvmsq_create,
	.mpo_sysvmsq_destroy_label = stub_destroy_label,
	.mpo_sysvmsq_init_label = stub_init_label,

	.mpo_sysvsem_check_semctl = stub_sysvsem_check_semctl,
	.mpo_sysvsem_check_semget = stub_sysvsem_check_semget,
	.mpo_sysvsem_check_semop = stub_sysvsem_check_semop,
	.mpo_sysvsem_cleanup = stub_sysvsem_cleanup,
	.mpo_sysvsem_create = stub_sysvsem_create,
	.mpo_sysvsem_destroy_label = stub_destroy_label,
	.mpo_sysvsem_init_label = stub_init_label,

	.mpo_sysvshm_check_shmat = stub_sysvshm_check_shmat,
	.mpo_sysvshm_check_shmctl = stub_sysvshm_check_shmctl,
	.mpo_sysvshm_check_shmdt = stub_sysvshm_check_shmdt,
	.mpo_sysvshm_check_shmget = stub_sysvshm_check_shmget,
	.mpo_sysvshm_cleanup = stub_sysvshm_cleanup,
	.mpo_sysvshm_create = stub_sysvshm_create,
	.mpo_sysvshm_destroy_label = stub_destroy_label,
	.mpo_sysvshm_init_label = stub_init_label,

	.mpo_system_check_acct = stub_system_check_acct,
	.mpo_system_check_audit = stub_system_check_audit,
	.mpo_system_check_auditctl = stub_system_check_auditctl,
	.mpo_system_check_auditon = stub_system_check_auditon,
	.mpo_system_check_reboot = stub_system_check_reboot,
	.mpo_system_check_swapoff = stub_system_check_swapoff,
	.mpo_system_check_swapon = stub_system_check_swapon,
	.mpo_system_check_sysctl = stub_system_check_sysctl,

	.mpo_thread_userret = stub_thread_userret,

	.mpo_vnode_associate_extattr = stub_vnode_associate_extattr,
	.mpo_vnode_associate_singlelabel = stub_vnode_associate_singlelabel,
	.mpo_vnode_check_access = stub_vnode_check_access,
	.mpo_vnode_check_chdir = stub_vnode_check_chdir,
	.mpo_vnode_check_chroot = stub_vnode_check_chroot,
	.mpo_vnode_check_create = stub_vnode_check_create,
	.mpo_vnode_check_deleteacl = stub_vnode_check_deleteacl,
	.mpo_vnode_check_deleteextattr = stub_vnode_check_deleteextattr,
	.mpo_vnode_check_exec = stub_vnode_check_exec,
	.mpo_vnode_check_getacl = stub_vnode_check_getacl,
	.mpo_vnode_check_getextattr = stub_vnode_check_getextattr,
	.mpo_vnode_check_link = stub_vnode_check_link,
	.mpo_vnode_check_listextattr = stub_vnode_check_listextattr,
	.mpo_vnode_check_lookup = stub_vnode_check_lookup,
	.mpo_vnode_check_mmap = stub_vnode_check_mmap,
	.mpo_vnode_check_mmap_downgrade = stub_vnode_check_mmap_downgrade,
	.mpo_vnode_check_mprotect = stub_vnode_check_mprotect,
	.mpo_vnode_check_open = stub_vnode_check_open,
	.mpo_vnode_check_poll = stub_vnode_check_poll,
	.mpo_vnode_check_read = stub_vnode_check_read,
	.mpo_vnode_check_readdir = stub_vnode_check_readdir,
	.mpo_vnode_check_readlink = stub_vnode_check_readlink,
	.mpo_vnode_check_relabel = stub_vnode_check_relabel,
	.mpo_vnode_check_rename_from = stub_vnode_check_rename_from,
	.mpo_vnode_check_rename_to = stub_vnode_check_rename_to,
	.mpo_vnode_check_revoke = stub_vnode_check_revoke,
	.mpo_vnode_check_setacl = stub_vnode_check_setacl,
	.mpo_vnode_check_setextattr = stub_vnode_check_setextattr,
	.mpo_vnode_check_setflags = stub_vnode_check_setflags,
	.mpo_vnode_check_setmode = stub_vnode_check_setmode,
	.mpo_vnode_check_setowner = stub_vnode_check_setowner,
	.mpo_vnode_check_setutimes = stub_vnode_check_setutimes,
	.mpo_vnode_check_stat = stub_vnode_check_stat,
	.mpo_vnode_check_unlink = stub_vnode_check_unlink,
	.mpo_vnode_check_write = stub_vnode_check_write,
	.mpo_vnode_copy_label = stub_copy_label,
	.mpo_vnode_create_extattr = stub_vnode_create_extattr,
	.mpo_vnode_destroy_label = stub_destroy_label,
	.mpo_vnode_execve_transition = stub_vnode_execve_transition,
	.mpo_vnode_execve_will_transition = stub_vnode_execve_will_transition,
	.mpo_vnode_externalize_label = stub_externalize_label,
	.mpo_vnode_init_label = stub_init_label,
	.mpo_vnode_internalize_label = stub_internalize_label,
	.mpo_vnode_relabel = stub_vnode_relabel,
	.mpo_vnode_setlabel_extattr = stub_vnode_setlabel_extattr,
};

MAC_POLICY_SET(&stub_ops, mac_stub, "TrustedBSD MAC/Stub",
    MPC_LOADTIME_FLAG_UNLOADOK, NULL);


text:
package goose

import (
	"log"

	mgo "gopkg.in/mgo.v2"
	"gopkg.in/mgo.v2/bson"
)

type docBase struct {
	ID bson.ObjectId `bson:"_id,omitempty" json:"_id"`
}

type schema struct {
	Name       string
	Collection *mgo.Collection
	Definition interface{}
}

type Goose struct {
	Session *mgo.Session
	DB      *mgo.Database
	Schemas map[string]schema
}

var instantiated *Goose = nil

func Init() *Goose {
	if instantiated == nil {
		instantiated = new(Goose)
	}
	instantiated.Schemas = make(map[string]schema)
	return instantiated
}

func (goose *Goose) Connect(connectionString, dbName string) (*mgo.Session, *mgo.Database) {
	session, err := mgo.Dial(connectionString)
	if err != nil {
		panic(err)
	}
	db := session.DB(dbName)
	goose.Session = session
	goose.DB = db
	return session, db
}

func (goose *Goose) Definition(name string) schema {
	_schema := schema{}
	if goose.Schemas[name] == (schema{}) {
		collection := goose.DB.C(name)
		_schema.Name = name
		_schema.Collection = collection
		goose.Schemas[name] = _schema
	}
	return goose.Schemas[name]
}

// Insert a new document
func (sch *schema) Save(doc interface{}) error {
	err := sch.Collection.Insert(doc)
	if err != nil {
		log.Printf("ERROR! %s\n", err)
	}
	return err
}

// Query documents in the collections
func (sch *schema) Index(page, count int, selectData []string, filter []byte) []bson.M {
	if page < 1 {
		page = 1
	}
	skip := count * (page - 1)
	var filterQuery interface{}
	bson.UnmarshalJSON(filter, &filterQuery)
	query := sch.Collection.Find(filterQuery).Sort("_id").Skip(skip).Limit(count)

	if len(selectData) > 1 {
		selectQuery := bson.M{}
		for _, v := range selectData {
			selectQuery[v] = 1
		}
		query = query.Select(selectQuery)
	}

	r := query.Iter()
	var resultSet []bson.M
	var p interface{}
	for {
		flag := r.Next(&p)
		if !flag {
			break
		}
		resultSet = append(resultSet, p.(bson.M))
	}

	return resultSet
}

// retrieve count of documents
func (sch *schema) Count(filter []byte) int {
	var filterQuery interface{}
	bson.UnmarshalJSON(filter, &filterQuery)
	query := sch.Collection.Find(filterQuery).Sort("_id")

	count, _ := query.Count()
	return count
}

// Get document
func (sch *schema) Get(id string, selectData []string) bson.M {
	query := sch.Collection.Find(bson.M{"_id": bson.ObjectIdHex(id)})

	if len(selectData) > 1 {
		selectQuery := bson.M{}
		for _, v := range selectData {
			selectQuery[v] = 1
		}
		query = query.Select(selectQuery)
	}

	var p bson.M
	query.One(&p)
	return p
}

// Update documents
func (sch *schema) Update(id string, _doc interface{}) (interface{}, bson.M) {
	var result bson.M
	doc := _doc.(map[string]interface{})
	delete(doc, "_id")
	change := mgo.Change{
		Update:    bson.M{"$set": doc},
		ReturnNew: true,
	}
	d, err := sch.Collection.Find(bson.M{"_id": bson.ObjectIdHex(id)}).Apply(change, &result)
	if err != nil {
		log.Println(err)
	}
	return d, result
}

// Delete documents
func (sch *schema) Delete(id string) error {
	err := sch.Collection.Remove(bson.M{"_id": bson.ObjectIdHex(id)})
	return err
}

func (sch *schema) SetIndex(keys []string, unique, dropDups, backgroud, sparse bool) {
	index := mgo.Index{
		Key:        keys,
		Unique:     unique,
		DropDups:   dropDups,
		Background: backgroud,
		Sparse:     sparse,
	}
	sch.Collection.EnsureIndex(index)
}


text:
import os

from starlette import status
from starlette.requests import Request
from starlette.responses import FileResponse, Response
from starlette.routing import Route

from polyaxon.api import STREAMS_V1_LOCATION
from polyaxon.fs.async_manager import (
    check_is_file,
    delete_file_or_dir,
    download_dir,
    download_file,
    list_files,
)
from polyaxon.utils.bool_utils import to_bool
from polyaxon_deploy.connections.fs import AppFS
from polyaxon_deploy.controllers.notebooks import render_notebook
from polyaxon_deploy.controllers.uploads import handle_upload
from polyaxon_deploy.endpoints.base import UJSONResponse
from polyaxon_deploy.endpoints.utils import redirect_file

def clean_path(filepath: str):
    return filepath.strip("/")

async def handle_artifact(request: Request) -> Response:
    if request.method == "GET":
        return await download_artifact(request)
    if request.method == "DELETE":
        return await delete_artifact(request)
    if request.method == "POST":
        return await upload_artifact(request)

async def ro_artifact(request: Request) -> Response:
    path = request.path_params["path"]
    return await download_artifact(request, path, True)

async def download_artifact(
    request: Request, path: str = None, stream: bool = None
) -> Response:
    run_uuid = request.path_params["run_uuid"]
    filepath = request.query_params.get("path", path or "")
    stream = to_bool(request.query_params.get("stream", stream), handle_none=True)
    force = to_bool(request.query_params.get("force"), handle_none=True)
    render = to_bool(request.query_params.get("render"), handle_none=True)
    if not filepath:
        return Response(
            content="A `path` query param is required to stream a file content",
            status_code=status.HTTP_400_BAD_REQUEST,
        )
    if render and not filepath.endswith(".ipynb"):
        return Response(
            content="Artifact with 'filepath={}' does not have a valid extension.".format(
                filepath
            ),
            status_code=status.HTTP_400_BAD_REQUEST,
        )
    subpath = "{}/{}".format(run_uuid, clean_path(filepath)).rstrip("/")
    archived_path = await download_file(
        fs=await AppFS.get_fs(), subpath=subpath, check_cache=not force
    )
    if not archived_path:
        return Response(
            content="Artifact not found: filepath={}".format(archived_path),
            status_code=status.HTTP_404_NOT_FOUND,
        )
    if stream:
        if render:
            archived_path = await render_notebook(
                archived_path=archived_path, check_cache=not force
            )
        return FileResponse(archived_path, filename=os.path.basename(archived_path))
    return await redirect_file(archived_path)

async def upload_artifact(request: Request) -> Response:
    return await handle_upload(fs=await AppFS.get_fs(), request=request, is_file=True)

async def delete_artifact(request: Request) -> Response:
    run_uuid = request.path_params["run_uuid"]
    filepath = request.query_params.get("path", "")
    if not filepath:
        return Response(
            content="A `path` query param is required to delete a file",
            status_code=status.HTTP_400_BAD_REQUEST,
        )
    subpath = "{}/{}".format(run_uuid, clean_path(filepath)).rstrip("/")
    is_deleted = await delete_file_or_dir(
        fs=await AppFS.get_fs(), subpath=subpath, is_file=True
    )
    if not is_deleted:
        return Response(
            content="Artifact could not be deleted: filepath={}".format(subpath),
            status_code=status.HTTP_400_BAD_REQUEST,
        )
    return Response(
        status_code=status.HTTP_204_NO_CONTENT,
    )

async def handle_artifacts(request: Request) -> Response:
    if request.method == "GET":
        return await download_artifacts(request)
    if request.method == "DELETE":
        return await delete_artifacts(request)
    if request.method == "POST":
        return await upload_artifacts(request)

async def download_artifacts(request: Request) -> Response:
    run_uuid = request.path_params["run_uuid"]
    check_path = to_bool(request.query_params.get("check_path"), handle_none=True)
    if not check_path:
        # Backwards compatibility
        check_path = to_bool(request.query_params.get("check_file"), handle_none=True)
    path = request.query_params.get("path", "")
    subpath = "{}/{}".format(run_uuid, clean_path(path)).rstrip("/")
    fs = await AppFS.get_fs()
    if check_path:
        is_file = await check_is_file(fs=fs, subpath=subpath)
        if is_file:
            return await download_artifact(request)
    archived_path = await download_dir(fs=fs, subpath=subpath, to_tar=True)
    if not archived_path:
        return Response(
            content="Artifact not found: filepath={}".format(archived_path),
            status_code=status.HTTP_404_NOT_FOUND,
        )
    return await redirect_file(archived_path)

async def upload_artifacts(request: Request) -> Response:
    return await handle_upload(fs=await AppFS.get_fs(), request=request, is_file=False)

async def delete_artifacts(request: Request) -> Response:
    run_uuid = request.path_params["run_uuid"]
    path = request.query_params.get("path", "")
    subpath = "{}/{}".format(run_uuid, clean_path(path)).rstrip("/")
    is_deleted = await delete_file_or_dir(
        fs=await AppFS.get_fs(), subpath=subpath, is_file=False
    )
    if not is_deleted:
        return Response(
            content="Artifacts could not be deleted: filepath={}".format(subpath),
            status_code=status.HTTP_400_BAD_REQUEST,
        )
    return Response(
        status_code=status.HTTP_204_NO_CONTENT,
    )

async def tree_artifacts(request: Request) -> UJSONResponse:
    run_uuid = request.path_params["run_uuid"]
    filepath = request.query_params.get("path", "")
    ls = await list_files(
        fs=await AppFS.get_fs(),
        subpath=run_uuid,
        filepath=clean_path(filepath),
        force=True,
    )
    return UJSONResponse(ls)

URLS_RUNS_ARTIFACT = (
    STREAMS_V1_LOCATION
    + "{namespace:str}/{owner:str}/{project:str}/runs/{run_uuid:str}/artifact"
)
URLS_RUNS_EMBEDDED_ARTIFACT = (
    STREAMS_V1_LOCATION
    + "{namespace:str}/{owner:str}/{project:str}/runs/{run_uuid:str}/embedded_artifact"
)
URLS_RUNS_RO_ARTIFACT = (
    STREAMS_V1_LOCATION
    + "{namespace:str}/{owner:str}/{project:str}/runs/{run_uuid:str}/ro_artifact/{path:path}"
)
URLS_RUNS_ARTIFACTS = (
    STREAMS_V1_LOCATION
    + "{namespace:str}/{owner:str}/{project:str}/runs/{run_uuid:str}/artifacts"
)
URLS_RUNS_ARTIFACTS_TREE = (
    STREAMS_V1_LOCATION
    + "{namespace:str}/{owner:str}/{project:str}/runs/{run_uuid:str}/artifacts/tree"
)

# fmt: off
artifacts_routes = [
    Route(
        URLS_RUNS_ARTIFACT,
        handle_artifact,
        name="download_artifact",
        methods=["GET", "DELETE", "POST"],
    ),
    Route(
        URLS_RUNS_EMBEDDED_ARTIFACT,
        handle_artifact,
        name="download_embedded_artifact",
        methods=["GET"],
    ),
    Route(
        URLS_RUNS_RO_ARTIFACT,
        ro_artifact,
        name="read_only_artifact",
        methods=["GET"],
    ),
    Route(
        URLS_RUNS_ARTIFACTS,
        handle_artifacts,
        name="download_artifacts",
        methods=["GET", "DELETE", "POST"],
    ),
    Route(
        URLS_RUNS_ARTIFACTS_TREE,
        tree_artifacts,
        name="list_artifacts",
        methods=["GET"],
    ),
]


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <ListView
    android:id="@android:id/list"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="@dimen/list_padding"
    android:paddingRight="@dimen/list_padding" />
</RelativeLayout>


text:
package org.fcrepo.integration.generator;

import static java.util.UUID.randomUUID;
import static java.util.regex.Pattern.DOTALL;
import static java.util.regex.Pattern.compile;
import static javax.ws.rs.core.MediaType.TEXT_XML;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.slf4j.LoggerFactory.getLogger;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPatch;
import org.apache.http.entity.BasicHttpEntity;
import org.apache.http.util.EntityUtils;
import org.junit.Test;
import org.slf4j.Logger;
import org.springframework.test.context.ContextConfiguration;

import java.io.ByteArrayInputStream;

/**
 *
DublinCoreGeneratorIT class.

 *
 * @author fasseg
 */
@ContextConfiguration({"/spring-test/test-container.xml"})
public class DublinCoreGeneratorIT extends AbstractResourceIT {

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

    @Test
    public void testJcrPropertiesBasedOaiDc() throws Exception {
        final HttpResponse response = createObject("");
        final String location = response.getFirstHeader("Location").getValue();
        final HttpPatch post = new HttpPatch(location);
        post.setHeader("Content-Type", "application/sparql-update");
        final BasicHttpEntity entity = new BasicHttpEntity();
        entity.setContent(new ByteArrayInputStream(
                ("INSERT { <> <http://purl.org/dc/elements/1.1/identifier> \"this is an identifier\" } WHERE {}")
                        .getBytes()));
        post.setEntity(entity);
        assertEquals(204, getStatus(post));
        final HttpGet getWorstCaseOaiMethod = new HttpGet(location + "/oai:dc");
        getWorstCaseOaiMethod.setHeader("Accept", TEXT_XML);
        final HttpResponse oaiResponse = client.execute(getWorstCaseOaiMethod);

        assertEquals(200, oaiResponse.getStatusLine().getStatusCode());

        final String content = EntityUtils.toString(oaiResponse.getEntity());
        logger.debug("Got content: {}", content);
        assertTrue("Didn't find oai_dc!", compile("oai_dc", DOTALL).matcher(content).find());

        assertTrue("Didn't find dc:identifier!", compile("dc:identifier", DOTALL).matcher(content).find());
    }

    @Test
    public void testWellKnownPathOaiDc() throws Exception {

        final String pid = randomUUID().toString();

        createObject(pid);
        createDatastream(pid, "DC", "marbles for everyone");

        final HttpGet getWorstCaseOaiMethod = new HttpGet(serverOAIAddress + pid + "/oai:dc");
        getWorstCaseOaiMethod.setHeader("Accept", TEXT_XML);
        final HttpResponse response = client.execute(getWorstCaseOaiMethod);
        assertEquals(200, response.getStatusLine().getStatusCode());
        final String content = EntityUtils.toString(response.getEntity());
        assertTrue("Didn't find our datastream!", compile("marbles for everyone", DOTALL).matcher(content).find());
    }
}


text:
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#nullable disable

using System.Collections.Immutable;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.FindSymbols;
using Microsoft.CodeAnalysis.FindSymbols.SymbolTree;
using Microsoft.CodeAnalysis.Shared.Extensions;

namespace Microsoft.CodeAnalysis.AddImport
{
    internal abstract partial class AbstractAddImportFeatureService<TSimpleNameSyntax>
    {
        private class MetadataSymbolsSearchScope : SearchScope
        {
            private readonly Project _assemblyProject;
            private readonly IAssemblySymbol _assembly;
            private readonly PortableExecutableReference _metadataReference;

            public MetadataSymbolsSearchScope(
                AbstractAddImportFeatureService<TSimpleNameSyntax> provider,
                Project assemblyProject,
                IAssemblySymbol assembly,
                PortableExecutableReference metadataReference,
                bool exact,
                CancellationToken cancellationToken)
                : base(provider, exact, cancellationToken)
            {
                _assemblyProject = assemblyProject;
                _assembly = assembly;
                _metadataReference = metadataReference;
            }

            public override SymbolReference CreateReference<T>(SymbolResult<T> searchResult)
            {
                return new MetadataSymbolReference(
                    provider,
                    searchResult.WithSymbol<INamespaceOrTypeSymbol>(searchResult.Symbol),
                    _assemblyProject.Id,
                    _metadataReference);
            }

            protected override async Task<ImmutableArray<ISymbol>> FindDeclarationsAsync(
                SymbolFilter filter, SearchQuery searchQuery)
            {
                var service = _assemblyProject.Solution.Services.GetService<ISymbolTreeInfoCacheService>();
                var info = await service.TryGetPotentiallyStaleMetadataSymbolTreeInfoAsync(_assemblyProject, _metadataReference, CancellationToken).ConfigureAwait(false);
                if (info == null)
                    return ImmutableArray<ISymbol>.Empty;

                var declarations = await info.FindAsync(
                    searchQuery, _assembly, filter, CancellationToken).ConfigureAwait(false);

                return declarations;
            }
        }
    }
}


text:
@class MovieDetailView;

extern NSString *FWSwipePlayerViewStateChange;

typedef enum _FWSwipeState {
    FWSwipeNone = 0,
    FWSwipeUp = 1,
    FWSwipeDown = 2,
    FWSwipeLeft = 3,
    FWSwipeRight = 4
} FWSwipeState;

@interface FWDraggableManager : NSObject<UIGestureRecognizerDelegate, FWPlayerDelegate>
@property (nonatomic, strong) FWSwipePlayerViewController *playerController;
@property (nonatomic, assign) FWSwipeState swipeState;

- (id)initWithInfo:(NSDictionary *)infoDict;
- (id)initWithInfo:(NSDictionary *)infoDict Config:(FWSwipePlayerConfig*)config;
- (id)initWithList:(NSArray *)dataList;
- (id)initWithList:(NSArray *)list Config:(FWSwipePlayerConfig*)config;
- (void)updateInfo:(NSDictionary *)infoDict;
- (void)setDetailView:(UIView*)detailView;

- (void)showAtController:(UIViewController *)controller;
- (void)showAtView:(UIView *)view;
- (void)showAtControllerAndPlay:(UIViewController *)controller;
- (void)showAtViewAndPlay:(UIView *)view;

- (void)exit;
@end


text:
#pragma once

#include <ddPlatform.h>

namespace DevDriver
{
    // Helper structure that sets value to true if T is not abstract and is constructable using the provided
    // arguments, otherwise it returns false. We use this to prevent the Create() function from being defined
    // for classes that are not creatable. This in turn prevents code from being generated that causes
    // Container to be defined, which leads to compile errors even if the client application never attempts
    // to directly create an object of that type.
    template<typename T, typename... Args>
    struct CanConstruct
    {
        DD_STATIC_CONST bool Value = !Platform::IsAbstract<T>::Value && Platform::IsConstructible<T, Args...>::Value;
    };

    // SharedPointerBase is the common parent class used by SharedPointer<>
    // It implements common functions (e.g., pointer management) but cannot ever be
    // used directly. The purpose of this separation is to enable SharedPointer to perform
    // typecasts between derived and base types by casting through SharedPointerBase.
    class SharedPointerBase
    {
        // SharedPointer is a subclass, but all need to have access to the protected + private members
        template<typename T>
        friend class SharedPointer;
        // public functions available to all subclasses
    public:
        // check to see if the class has been set
        bool IsNull() const { return m_pObject == nullptr; }

        // clear the pointer and, if required, delete the underlying allocation
        void Clear()
        {
            if (m_pContainer != nullptr)
            {
                if (m_pContainer->Release() == 0)
                {
                    // ContainerBase has been declared with a virtual destructor, which guarantees
                    // that the specific ContainerBase subclass destructor is called
                    DD_DELETE(m_pContainer, m_pContainer->GetAllocCb());
                }
                m_pContainer = nullptr;
                m_pObject = nullptr;
            }
        }

    protected:
        // Inner class that provides a standardized reference counted container interface
        // Subclassed by SharedPointer to include an actual object
        class ContainerBase
        {
        public:
            // Construct container and initialize ref count to zero. This class should never be
            // constructed directly by anything other than a subclass.
            constexpr ContainerBase(const AllocCb &allocCb)
                : m_allocCb(allocCb)
                , m_refCount(0)
            {
                //DD_PRINT(LogLevel::Never, "Created reference counted container %i", m_refCount);
            }

            // Destroy the container. Since this class is never directly created, this ensures
            // subclasses (and the contained object) are always destroyed correctly.
            virtual ~ContainerBase()
            {
                DD_ASSERT(m_refCount == 0);
                DD_PRINT(LogLevel::Never, "Deleted reference counted container %i", m_refCount);
            }

            // Increments the reference count of the container
            int32 Retain(void)
            {
                DD_ASSERT(m_refCount >= 0);
                int32 result = Platform::AtomicIncrement(&m_refCount);
                DD_ASSERT(result >= 1);
                DD_PRINT(LogLevel::Never, "Incremented reference count: %i", result);
                return result;
            }

            // Decrements the reference count of the container
            int32 Release(void)
            {
                int32 result = Platform::AtomicDecrement(&m_refCount);
                DD_ASSERT(result >= 0);
                DD_PRINT(LogLevel::Never, "Decremented reference count: %i", result);
                return result;
            }

            // Returns the reference count of the container
            int32 QueryReferenceCount(void) const
            {
                return m_refCount;
            }

            // Retrieve the allocator callbacks so it can be destroyed
            const AllocCb& GetAllocCb() const { return m_allocCb; }
        private:
            // Allocator callbacks
            const AllocCb       m_allocCb;
            // Reference count
            Platform::Atomic    m_refCount;

        };

        // Default constructor that is constexpr. Allows the compiler to inline this if it wants to.
        constexpr SharedPointerBase()
            : m_pContainer(nullptr)
            , m_pObject(nullptr)
        {
        }

        // Initialize the object using the provided pointer
        SharedPointerBase(ContainerBase* pContainer, void* pObject)
            : m_pContainer(pContainer)
            , m_pObject(pObject)
        {
            // We should always have a valid object if the container is valid.
            DD_ASSERT((m_pContainer == nullptr) || (m_pObject != nullptr));

            // If we have a valid container, increment the reference count.
            if (m_pContainer != nullptr)
            {
                m_pContainer->Retain();
            }
        }

        // Copy constructor copies the container pointer and increments the reference count
        SharedPointerBase(const SharedPointerBase &right)
            : SharedPointerBase(right.m_pContainer, right.m_pObject)
        {
        }

        // Move constructor takes the container pointer and clears the other container's pointer
        SharedPointerBase(SharedPointerBase &&right)
            : m_pContainer(Platform::Exchange(right.m_pContainer, nullptr))
            , m_pObject(Platform::Exchange(right.m_pObject, nullptr))
        {
        }

        // On deletion of the object clear the pointer
        ~SharedPointerBase()
        {
            Clear();
        }
    private:
        // Pointer to the shared container
        ContainerBase* m_pContainer;
        // Pointer to the object inside the shared container. We keep a copy of this to allow
        // direct access to the object since we might not know the actual parent type of it.
        void*          m_pObject;
    };

    template <typename T>
    class SharedPointer : public SharedPointerBase
    {
    public:
        // Create SharedPointer object with the default constructor
        constexpr SharedPointer() : SharedPointerBase() {};

        SharedPointer(const SharedPointer<T>&) = default;

        // Copy conversion constructor. Creates a new object if you can cast from type U to type T.
        template <typename U, typename = typename Platform::EnableIf<Platform::IsConvertible<U*, T*>::Value>::Type>
        SharedPointer(const SharedPointer<U> &right)
            : SharedPointerBase(Platform::Forward<const SharedPointerBase>(right))
        {
        }

        // Move conversion constructor. Takes ownership of the shared container if you can cast from type U to type T.
        template <typename U, typename = typename Platform::EnableIf<Platform::IsConvertible<U*, T*>::Value>::Type>
        SharedPointer(SharedPointer<U> &&right)
            : SharedPointerBase(Platform::Forward<SharedPointerBase>(right))
        {
        }

        // Assignment operator to allow copy + swap idiom
        SharedPointer<T> &operator= (SharedPointer<T> right)
        {
            m_pContainer = Platform::Exchange(right.m_pContainer, m_pContainer);
            m_pObject = Platform::Exchange(right.m_pObject, m_pObject);
            return *this;
        }

        // Indirection operator. Returns a const reference to the object in the shared container.
        // This operator is unsafe to use if the container hasn't been allocated.
        T& operator*() const
        {
            DD_ASSERT(m_pObject != nullptr);
            return *Get();
        }

        // Member of pointer operator. Returns a pointer to the object in the shared container.
        // This operator is unsafe to use if the container hasn't been allocated.
        T* operator->() const
        {
            DD_ASSERT(m_pObject != nullptr);
            return Get();
        }

        // Templated comparison operator. Allows comparing shared pointer objects so long as U is convertable to T.
        template <typename U, typename = typename Platform::EnableIf<Platform::IsConvertible<U*, T*>::Value>::Type>
        bool operator== (const SharedPointer< U >&right) const
        {
            return m_pObject == right.m_pObject;
        }

        // Templated comparison operator. Allows comparing shared pointer objects so long as U is convertable to T.
        template <typename U, typename = typename Platform::EnableIf<Platform::IsConvertible<U*, T*>::Value>::Type>
        bool operator!= (const SharedPointer< U >&right) const
        {
            return m_pObject != right.m_pObject;
        }

        // Get a pointer to the contained object
        T* Get() const
        {
            return static_cast<T* const>(m_pObject);
        }

        // Returns the reference count for the container
        int32 QueryReferenceCount() const
        {
            return m_pContainer->QueryReferenceCount();
        }

        // Create a SharedPointer using the provided allocator callbacks and arguments
        // This function is only valid if the class is not a valid class
        template<typename... Args,
            typename = typename Platform::EnableIf<CanConstruct<T, Args...>::Value>::Type>
            static SharedPointer<T> Create(const AllocCb& allocCb, Args&&... args)
        {
            SharedPointer result;
            Container *pContainer =
                DD_NEW(Container, allocCb)(allocCb, Platform::Forward<Args>(args)...);

            if (pContainer != nullptr)
            {
                result = SharedPointer(pContainer, &pContainer->m_object);
            }
            return result;
        }
    private:
        // Templated Container class that inherents the type from the outer (SharedPointer) class
        class Container : public ContainerBase
        {
        public:
            // Constructor that initializes ContainerBase class and the object using the provided parameters
            template<typename... Args>
            explicit constexpr Container(const AllocCb& allocCb, Args&&... args)
                : ContainerBase(allocCb)
                , m_object(Platform::Forward<Args>(args)...)
            {
            }

            // Actual object that the SharedPointer instance encapsulates
            T m_object;
        };

        // Private constructor to allow direct initialization using an externally created Container
        explicit SharedPointer(Container* pContainer, T* pObject)
            : SharedPointerBase(static_cast<ContainerBase*>(pContainer), pObject)
        {
        }
    };
} // DevDriver


text:
/*
**  @file tc3DTerrain.h
*/
/*
**  Copyright (c) 2014, GCBLUE 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. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from
**     this software without specific prior written permission.
**
**  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS 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
**  COPYRIGHT HOLDER OR 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.
*/

#ifndef _3DTERRAIN_H_
#define _3DTERRAIN_H_

#ifdef WIN32
#pragma once
#endif

#include "tv_types.h"
#include <boost/shared_ptr.hpp>

class tcMapData;
class tcTerrainTextureFactory;
class CTVGraphicEffect;
class CTVLandscape;
class CTVMesh;
class CTVRenderSurface;

class tcTexture2D;

/**
* Class to use Demeter terrain library to display 3D terrain
* using data in tcMapData.
*/
class tc3DTerrain
{
public:

    void AttachMapData(tcMapData *pMapData) {mapData=pMapData;}
    void Enable(bool state);
    float GetElevation(float x, float y);
	float GetOriginElevation();

    CTVRenderSurface* GetReflectionRS();
    CTVRenderSurface* GetRefractionRS();
    CTVGraphicEffect* GetWaterEffect();
    CTVLandscape* GetLandscape();
    CTVMesh* GetWaterMesh();
    CTVMesh* GetSimpleWaterMesh();

    void SetWaterColor(const Vec4& reflection, const Vec4& refraction, float customFresnel);

    void SetGameTime(double t) {gameTime = t;}
    void SetOrigin(double lon, double lat); ///< sets origin of 3D world coordinates
    void SetWindowSize(int width_, int height_);

    void Update();
    void UpdateCameraPosition(const Vec3& pos);

    tc3DTerrain();
    ~tc3DTerrain();
private:
	struct WaterTileInfo
	{
		float half_width;
		float xc;
		float yc;
	};
    enum
    {
        GRID_DIM = 256,
        TEX_CELL_DIM = 1,  ///< number of texture cells on side of grid
		BASE_TEX_DIM = 515
    };
	tcMapData* mapData; ///< pointer to tcMapData object
    float gridSpacing; ///< distance between neighbors in terrain grid [world coord units=m]
    float gridOffset; ///< offset for x and y for (0,0) grid element
    float elevationArray[(GRID_DIM)*(GRID_DIM)];
    bool isEnabled;

    CTVLandscape* landscape;

    CTVMesh* water;
    CTVMesh* simpleWater;
    CTVRenderSurface* waterReflection;
    CTVRenderSurface* waterRefraction;
    CTVGraphicEffect* waterEffect;
    cTV_PLANE waterPlane;
    cTV_COLOR waterReflectionColor;
    cTV_COLOR waterRefractionColor;

    int width;
    int height;

    boost::shared_ptr<tcTexture2D> terrainTexture;
    boost::shared_ptr<tcTexture2D> detailTexture;

	//Demeter::Texture* baseTexture;  ///< texture to drape over terrain, RGB bytes

    //osg::ref_ptr<Demeter::Terrain> terrain; ///< Demeter terrain object
    //osg::ref_ptr<osg::Geode> terrainNode; ///< drawable terrain object to place into osg scenegraph
    //osg::ref_ptr<osg::Geometry> waterSurface;
    //osg::ref_ptr<osg::Texture2D> waterTexture;

    tcTerrainTextureFactory* terrainTextureFactory;

    // these members are the same as in tc3DViewer (copied for simplicity for now)
    double lonOrigin_rad; ///< longitude for x = 0 in 3D world coords
    double latOrigin_rad; ///< latitude for z = 0 in 3D world coords (-z is North)
    double lonToGridX; ///< scale factor to convert to world coords
    double latToGridY; ///< scale factor to convert to world coords
    double gridXToLon; ///< scale factor to convert from world coords
    double gridYToLat; ///< scale factor to convert from world coords
    double gameTime; ///< current game time [s]

    // variables for gradual update
    bool updateScheduled;
    bool updating;
    int update_i;
    bool doGradualUpdate; ///< true to update elevation over multiple frames
	bool terrainShaderOn;

    float LonToX(double lon);
    float LatToY(double lat);
    double XToLon(float x);
    double YToLat(float y);
    void CheckElevations();
    void SetupWater();
    void UpdateElevations();
    void UpdateElevationsSlowly();
};

#endif


text:
package terraform

import (
	"fmt"

	"github.com/hashicorp/terraform-plugin-sdk/internal/plans"
	"github.com/hashicorp/terraform-plugin-sdk/internal/providers"
	"github.com/hashicorp/terraform-plugin-sdk/internal/states"

	"github.com/hashicorp/terraform-plugin-sdk/internal/addrs"
	"github.com/zclconf/go-cty/cty"
)

// NodePlannableResourceInstance represents a _single_ resource
// instance that is plannable. This means this represents a single
// count index, for example.
type NodePlannableResourceInstance struct {
	*NodeAbstractResourceInstance
	ForceCreateBeforeDestroy bool
}

var (
	_ GraphNodeSubPath              = (*NodePlannableResourceInstance)(nil)
	_ GraphNodeReferenceable        = (*NodePlannableResourceInstance)(nil)
	_ GraphNodeReferencer           = (*NodePlannableResourceInstance)(nil)
	_ GraphNodeResource             = (*NodePlannableResourceInstance)(nil)
	_ GraphNodeResourceInstance     = (*NodePlannableResourceInstance)(nil)
	_ GraphNodeAttachResourceConfig = (*NodePlannableResourceInstance)(nil)
	_ GraphNodeAttachResourceState  = (*NodePlannableResourceInstance)(nil)
	_ GraphNodeEvalable             = (*NodePlannableResourceInstance)(nil)
)

// GraphNodeEvalable
func (n *NodePlannableResourceInstance) EvalTree() EvalNode {
	addr := n.ResourceInstanceAddr()

	// Eval info is different depending on what kind of resource this is
	switch addr.Resource.Resource.Mode {
	case addrs.ManagedResourceMode:
		return n.evalTreeManagedResource(addr)
	case addrs.DataResourceMode:
		return n.evalTreeDataResource(addr)
	default:
		panic(fmt.Errorf("unsupported resource mode %s", n.Config.Mode))
	}
}

func (n *NodePlannableResourceInstance) evalTreeDataResource(addr addrs.AbsResourceInstance) EvalNode {
	config := n.Config
	var provider providers.Interface
	var providerSchema *ProviderSchema
	var change *plans.ResourceInstanceChange
	var state *states.ResourceInstanceObject
	var configVal cty.Value

	return &EvalSequence{
		Nodes: []EvalNode{
			&EvalGetProvider{
				Addr:   n.ResolvedProvider,
				Output: &provider,
				Schema: &providerSchema,
			},

			&EvalReadState{
				Addr:           addr.Resource,
				Provider:       &provider,
				ProviderSchema: &providerSchema,

				Output: &state,
			},

			// If we already have a non-planned state then we already dealt
			// with this during the refresh walk and so we have nothing to do
			// here.
			&EvalIf{
				If: func(ctx EvalContext) (bool, error) {
					depChanges := false

					// Check and see if any of our dependencies have changes.
					changes := ctx.Changes()
					for _, d := range n.StateReferences() {
						ri, ok := d.(addrs.ResourceInstance)
						if !ok {
							continue
						}
						change := changes.GetResourceInstanceChange(ri.Absolute(ctx.Path()), states.CurrentGen)
						if change != nil && change.Action != plans.NoOp {
							depChanges = true
							break
						}
					}

					refreshed := state != nil && state.Status != states.ObjectPlanned

					// If there are no dependency changes, and it's not a forced
					// read because we there was no Refresh, then we don't need
					// to re-read. If any dependencies have changes, it means
					// our config may also have changes and we need to Read the
					// data source again.
					if !depChanges && refreshed {
						return false, EvalEarlyExitError{}
					}
					return true, nil
				},
				Then: EvalNoop{},
			},

			&EvalValidateSelfRef{
				Addr:           addr.Resource,
				Config:         config.Config,
				ProviderSchema: &providerSchema,
			},

			&EvalReadData{
				Addr:           addr.Resource,
				Config:         n.Config,
				Dependencies:   n.StateReferences(),
				Provider:       &provider,
				ProviderAddr:   n.ResolvedProvider,
				ProviderSchema: &providerSchema,
				ForcePlanRead:  true, // _always_ produce a Read change, even if the config seems ready
				OutputChange:   &change,
				OutputValue:    &configVal,
				OutputState:    &state,
			},

			&EvalWriteState{
				Addr:           addr.Resource,
				ProviderAddr:   n.ResolvedProvider,
				ProviderSchema: &providerSchema,
				State:          &state,
			},

			&EvalWriteDiff{
				Addr:           addr.Resource,
				ProviderSchema: &providerSchema,
				Change:         &change,
			},
		},
	}
}

func (n *NodePlannableResourceInstance) evalTreeManagedResource(addr addrs.AbsResourceInstance) EvalNode {
	config := n.Config
	var provider providers.Interface
	var providerSchema *ProviderSchema
	var change *plans.ResourceInstanceChange
	var state *states.ResourceInstanceObject

	return &EvalSequence{
		Nodes: []EvalNode{
			&EvalGetProvider{
				Addr:   n.ResolvedProvider,
				Output: &provider,
				Schema: &providerSchema,
			},

			&EvalReadState{
				Addr:           addr.Resource,
				Provider:       &provider,
				ProviderSchema: &providerSchema,

				Output: &state,
			},

			&EvalValidateSelfRef{
				Addr:           addr.Resource,
				Config:         config.Config,
				ProviderSchema: &providerSchema,
			},

			&EvalDiff{
				Addr:                addr.Resource,
				Config:              n.Config,
				CreateBeforeDestroy: n.ForceCreateBeforeDestroy,
				Provider:            &provider,
				ProviderAddr:        n.ResolvedProvider,
				ProviderSchema:      &providerSchema,
				State:               &state,
				OutputChange:        &change,
				OutputState:         &state,
			},
			&EvalCheckPreventDestroy{
				Addr:   addr.Resource,
				Config: n.Config,
				Change: &change,
			},
			&EvalWriteState{
				Addr:           addr.Resource,
				ProviderAddr:   n.ResolvedProvider,
				State:          &state,
				ProviderSchema: &providerSchema,
			},
			&EvalWriteDiff{
				Addr:           addr.Resource,
				ProviderSchema: &providerSchema,
				Change:         &change,
			},
		},
	}
}


text:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace DictionaryFilter
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }

        private void GenerateDictionary()
        {

            // load and split by newline - trim again later to remove the \r
            string[] bigdictionary = System.IO.File.ReadAllText(txtInputFile.Text).Split('\n');

            // load and cache lowered front filter
            string frontFilterLower = txtFrontFilter.Text.ToLower();

            // load any length filters
            int lengthFilter = -1;
            if (txtLimitLength.Text.Length != 0)
            {
                lengthFilter = int.Parse(txtLimitLength.Text);
            }

            // load charset
            char[] charset = txtCharset.Text.ToCharArray();

            List<string> filteredList = new List<string>();

            // NOTE: filtering should ideally be done in ascending order of processing time

            foreach (string word in bigdictionary)
            {
                string tidyWord = word.Trim();

                // ignore blank lines
                if (tidyWord.Length == 0)
                {
                    continue;
                }

                // ignore mismatched lengths if user sets so
                if (lengthFilter != -1)
                {
                    if (tidyWord.Length != lengthFilter)
                    {
                        continue;
                    }
                }

                // apply front filter if user sets so
                if (frontFilterLower.Length != 0)
                {
                    if (Head(tidyWord, frontFilterLower.Length).ToLower() != frontFilterLower)
                    {
                        continue;
                    }
                }

                // check if word matches charset
                if (!StringIsWithinCharset(tidyWord, charset))
                {
                    continue;
                }

                filteredList.Add(tidyWord);
            }

            // generate the output
            List<string> outputFormattingList = new List<string>();

            foreach (string word in filteredList)
            {
                if (cbOriginal.Checked)
                {
                    outputFormattingList.Add(word);
                }

                if (cbUppercase.Checked)
                {
                    outputFormattingList.Add(word.ToUpper());
                }

                if (cbLowercase.Checked)
                {
                    outputFormattingList.Add(word.ToLower());
                }

                if (cbProperCase.Checked)
                {
                    outputFormattingList.Add(
                        Head(word.ToUpper()) +
                        Tail(word.ToLower())
                    );
                }

            }

            // make unique if need
            if (cbUnique.Checked)
            {
                List<string> finalList = new List<string>();
                finalList = outputFormattingList.Select(word => word).Distinct().ToList();
                SaveListOfStringToWordlist(finalList, txtOutputFile.Text);
            }
            else
            {
                SaveListOfStringToWordlist(outputFormattingList, txtOutputFile.Text);
            }

        }

        #region "String manipulation methods"

        // head/tail/init/last -> see http://learnyouahaskell.com/starting-out
        static string Head(string theWord, int headLength = 1)
        {
            if (theWord.Length > headLength)
            {
                return theWord.Remove(headLength);
            }
            return theWord;
        }

        static string Tail(string theWord, int headLength = 1)
        {
            if (theWord.Length > headLength)
            {
                return theWord.Remove(0, headLength);
            }
            return "";
        }

        static void SaveListOfStringToWordlist(List<string> theWordlist, string path)
        {
            StringBuilder sb = new StringBuilder();
            foreach (string word in theWordlist)
            {
                sb.AppendLine(word);
            }
            System.IO.File.WriteAllText(path, sb.ToString());
        }

        private static bool StringIsWithinCharset(String str, char[] charset)
        {
            bool canPass = true;
            char[] charArray = str.ToCharArray();
            foreach (char c in charArray)
            {
                if (!ContainsValidChar(c, charset))
                {
                    canPass = false;
                }
            }

            return canPass;
        }

        private static bool ContainsValidChar(char theChar, char[] charset)
        {
            foreach (char c in charset)
            {
                if (theChar == c)
                {
                    return true;
                }
            }
            return false;
        }
        #endregion

        private void btnSetInputFile_Click(object sender, EventArgs e)
        {
            using (var ofd = new OpenFileDialog())
            {
                if (ofd.ShowDialog() == DialogResult.OK)
                {
                    txtInputFile.Text = ofd.FileName;
                }
            }
        }

        private void btnSetOutputFile_Click(object sender, EventArgs e)
        {
            using (var sfd = new SaveFileDialog())
            {
                if (sfd.ShowDialog() == DialogResult.OK)
                {
                    txtOutputFile.Text = sfd.FileName;
                }
            }
        }

        private void btnRun_Click(object sender, EventArgs e)
        {
            GenerateDictionary();
            MessageBox.Show("Completed!");
        }
    }
}