text:
<?xml version="1.0" ?>
<!-- Based on https://ted.europa.eu/udl?uri=TED:NOTICE:177391-2020:TEXT:EN:HTML
-->
<ContractNotice xmlns="urn:oasis:names:specification:ubl:schema:xsd:ContractNotice-2" xmlns:ext="urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2" xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2" xmlns:efext="http://data.europa.eu/p27/eforms-ubl-extensions/1" xmlns:efbc="http://data.europa.eu/p27/eforms-ubl-extension-basic-components/1" xmlns:efac="http://data.europa.eu/p27/eforms-ubl-extension-aggregate-components/1" xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<ext:UBLExtensions>
		<ext:UBLExtension>
			<ext:ExtensionContent>
				<efext:EformsExtension>
					<efac:NoticeSubType>
						<cbc:SubTypeCode>19</cbc:SubTypeCode>
					</efac:NoticeSubType>
					<efac:Organizations>
						<efac:Organization>
							<efac:Company>
								<cbc:WebsiteURI>http://www.pro-marchespublics.com</cbc:WebsiteURI>
								<cbc:EndpointID>http://www.pro-marchespublics.com</cbc:EndpointID>
								<cac:PartyIdentification>
									<cbc:ID schemeName="organization">ORG-0001</cbc:ID>
								</cac:PartyIdentification>
								<cac:PartyName>
									<cbc:Name languageID="FRA">Communauté de communes Loches sud Touraine</cbc:Name>
								</cac:PartyName>
								<cac:PostalAddress>
									<cbc:StreetName>12 avenue de la Liberté</cbc:StreetName>
									<cbc:CityName>Loches</cbc:CityName>
									<cbc:PostalZone>37600</cbc:PostalZone>
									<cbc:CountrySubentityCode listName="nuts">FRB04</cbc:CountrySubentityCode>
									<cac:Country>
										<cbc:IdentificationCode>FRA</cbc:IdentificationCode>
									</cac:Country>
								</cac:PostalAddress>
								<cac:PartyLegalEntity>
									<cbc:CompanyID> 20007158700014</cbc:CompanyID>
								</cac:PartyLegalEntity>
								<cac:Contact>
									<cbc:Name>Florence Magnol</cbc:Name>
									<cbc:Telephone>+33 247919391</cbc:Telephone>
									<cbc:ElectronicMail>florence.magnol@lochessudtouraine.com</cbc:ElectronicMail>
								</cac:Contact>
							</efac:Company>
						</efac:Organization>
						<efac:Organization>
							<efac:Company>
								<cac:PartyIdentification>
									<cbc:ID schemeName="organization">ORG-0002</cbc:ID>
								</cac:PartyIdentification>
								<cac:PartyName>
									<cbc:Name languageID="FRA">Tribunal administratif d'Orléans</cbc:Name>
								</cac:PartyName>
								<cac:PostalAddress>
									<cbc:StreetName>28 rue de la Bretonnerie</cbc:StreetName>
									<cbc:CityName>Orleans</cbc:CityName>
									<cbc:PostalZone>45057</cbc:PostalZone>
									<cac:Country>
										<cbc:IdentificationCode>FRA</cbc:IdentificationCode>
									</cac:Country>
								</cac:PostalAddress>
								<cac:PartyLegalEntity>
									<cbc:CompanyID schemeID="002">123 456 789</cbc:CompanyID>
								</cac:PartyLegalEntity>
								<cac:Contact>
									<cbc:Name>Greffe</cbc:Name>
									<cbc:Telephone>+33 238775900</cbc:Telephone>
									<cbc:Telefax>+33 238538516</cbc:Telefax>
									<cbc:ElectronicMail>greffe.ta-orleans@juradm.fr</cbc:ElectronicMail>
								</cac:Contact>
							</efac:Company>
						</efac:Organization>
						<efac:Organization>
							<efac:Company>
								<cac:PartyIdentification>
									<cbc:ID schemeName="organization">ORG-0003</cbc:ID>
								</cac:PartyIdentification>
								<cac:PartyName>
									<cbc:Name languageID="FRA">Médiateur Exemple</cbc:Name>
								</cac:PartyName>
								<cac:PostalAddress>
									<cbc:StreetName>1 rue du Médiateur</cbc:StreetName>
									<cbc:CityName>Médiateurville</cbc:CityName>
									<cac:Country>
										<cbc:IdentificationCode listName="country">FRA</cbc:IdentificationCode>
									</cac:Country>
								</cac:PostalAddress>
								<cac:PartyLegalEntity>
									<cbc:CompanyID schemeName="abc">111 111 111</cbc:CompanyID>
								</cac:PartyLegalEntity>
								<cac:Contact>
									<cbc:Telephone>+123 456 789</cbc:Telephone>
									<cbc:ElectronicMail>contact@example.com</cbc:ElectronicMail>
								</cac:Contact>
							</efac:Company>
						</efac:Organization>
						<efac:Organization>
							<efac:Company>
								<cac:PartyIdentification>
									<cbc:ID schemeName="organization">ORG-0004</cbc:ID>
								</cac:PartyIdentification>
								<cac:PartyName>
									<cbc:Name languageID="FRA">eSendCorp</cbc:Name>
								</cac:PartyName>
								<cac:PostalAddress>
									<cbc:CityName>Luxembourg</cbc:CityName>
									<cac:Country>
										<cbc:IdentificationCode listName="country">LUX</cbc:IdentificationCode>
									</cac:Country>
								</cac:PostalAddress>
								<cac:PartyLegalEntity>
									<cbc:CompanyID schemeID="123">111 222 333</cbc:CompanyID>
								</cac:PartyLegalEntity>
								<cac:Contact>
									<cbc:Telephone>+352 123456789</cbc:Telephone>
									<cbc:ElectronicMail>esender@example.com</cbc:ElectronicMail>
								</cac:Contact>
							</efac:Company>
						</efac:Organization>
					</efac:Organizations>
				</efext:EformsExtension>
			</ext:ExtensionContent>
		</ext:UBLExtension>
	</ext:UBLExtensions>
	<cbc:UBLVersionID>2.3</cbc:UBLVersionID>
	<cbc:CustomizationID>eforms-sdk-0.4</cbc:CustomizationID>
	<cbc:ID>4039abd1-af19-42cf-bce0-7c55806601e8</cbc:ID>
	<cbc:ContractFolderID>fe181e9c-327f-4a7c-8669-ef0774c9a749</cbc:ContractFolderID>
	<cbc:IssueDate>2020-04-14+01:00</cbc:IssueDate>
	<cbc:IssueTime>04:44:04+01:00</cbc:IssueTime>
	<cbc:VersionID>01</cbc:VersionID>
	<cbc:RegulatoryDomain>32014L0023</cbc:RegulatoryDomain>
	<cbc:NoticeTypeCode listName="competition">cn-standard</cbc:NoticeTypeCode>
	<cbc:NoticeLanguageCode>FRA</cbc:NoticeLanguageCode>
	<cac:ContractingParty>
		<cbc:BuyerProfileURI>http://www.pro-marchespublics.com</cbc:BuyerProfileURI>
		<cac:ContractingPartyType>
			<cbc:PartyTypeCode listName="buyer-legal-type">body-pl</cbc:PartyTypeCode>
		</cac:ContractingPartyType>
		<cac:ContractingPartyType>
			<cbc:PartyTypeCode listName="buyer-contracting-type">not-cont-ent</cbc:PartyTypeCode>
		</cac:ContractingPartyType>
		<cac:ContractingActivity>
			<cbc:ActivityTypeCode listName="authority-activity">gen-pub</cbc:ActivityTypeCode>
		</cac:ContractingActivity>
		<cac:Party>
			<cac:PartyIdentification>
				<cbc:ID schemeName="organization">ORG-0001</cbc:ID>
			</cac:PartyIdentification>
			<cac:ServiceProviderParty>
				<cbc:ServiceTypeCode listName="organisation-role">ted-esen</cbc:ServiceTypeCode>
				<cac:Party>
					<cac:PartyIdentification>
						<cbc:ID schemeName="organization">ORG-0004</cbc:ID>
					</cac:PartyIdentification>
				</cac:Party>
			</cac:ServiceProviderParty>
		</cac:Party>
	</cac:ContractingParty>
	<cac:TenderingTerms>
		<cac:LotDistribution>
			<cbc:MaximumLotsAwardedNumeric>1</cbc:MaximumLotsAwardedNumeric>
			<cbc:MaximumLotsSubmittedNumeric>1</cbc:MaximumLotsSubmittedNumeric>
		</cac:LotDistribution>
	</cac:TenderingTerms>
	<cac:TenderingProcess>
		<cbc:SubmissionMethodCode listName="esubmission">required</cbc:SubmissionMethodCode>
	</cac:TenderingProcess>
	<cac:ProcurementProject>
		<cbc:ID>Dsp crèches</cbc:ID>
		<cbc:Name languageID="FRA">Concession de service public pour la gestion des équipements d'accueil collectif de la petite enfance — secteur nord-est Loches et Tauxigny-Saint-Bauld</cbc:Name>
		<cbc:Description languageID="FRA">— la présente concession de service sous-forme de DSP concerne deux structures de type multi-accueils de quarante berceaux chacune</cbc:Description>
		<cbc:ProcurementTypeCode listName="contract-nature">services</cbc:ProcurementTypeCode>
		<cbc:Note languageID="FRA">Les dépôts de plis doivent être impérativement remis par voie dématérialisée. Cette consultation bénéficie du service DUME. Pour retrouver cet avis intégral, accéder au DCE, poser des questions à l'acheteur, déposer un pli, allez sur http://www.pro-marchespublics.com -</cbc:Note>
		<cac:MainCommodityClassification>
			<cbc:ItemClassificationCode listName="cpv">85312110</cbc:ItemClassificationCode>
		</cac:MainCommodityClassification>
		<cac:AdditionalCommodityClassification>
			<cbc:ItemClassificationCode listName="cpv">85312110</cbc:ItemClassificationCode>
		</cac:AdditionalCommodityClassification>
		<cac:RealizedLocation>
			<cac:Address>
				<cbc:CountrySubentityCode listName="nuts">FRB04</cbc:CountrySubentityCode>
			</cac:Address>
		</cac:RealizedLocation>
	</cac:ProcurementProject>
	<cac:ProcurementProjectLot>
		<cbc:ID schemeName="Lot">LOT-0000</cbc:ID>
		<cac:TenderingTerms>
			<ext:UBLExtensions>
				<ext:UBLExtension>
					<ext:ExtensionContent>
						<efext:EformsExtension>
							<efac:SelectionCriteria>
								<cbc:CriterionTypeCode listName="selection-criterion">ef-stand</cbc:CriterionTypeCode>
								<cbc:Description languageID="FRA">NOT AVAILABLE</cbc:Description>
								<cbc:CalculationExpressionCode listName="usage">used</cbc:CalculationExpressionCode>
							</efac:SelectionCriteria>
						</efext:EformsExtension>
					</ext:ExtensionContent>
				</ext:UBLExtension>
			</ext:UBLExtensions>
			<cbc:FundingProgramCode listName="eu-funded">no-eu-funds</cbc:FundingProgramCode>
			<cac:CallForTendersDocumentReference>
				<cbc:ID>Identifier1</cbc:ID>
				<cbc:DocumentType>non-restricted-document</cbc:DocumentType>
			</cac:CallForTendersDocumentReference>
			<cac:TendererQualificationRequest>
				<cac:SpecificTendererRequirement>
					<cbc:TendererRequirementTypeCode listName="reserved-procurement">none</cbc:TendererRequirementTypeCode>
				</cac:SpecificTendererRequirement>
			</cac:TendererQualificationRequest>
			<cac:ContractExecutionRequirement>
				<cbc:ExecutionRequirementCode listName="reserved-execution">no</cbc:ExecutionRequirementCode>
			</cac:ContractExecutionRequirement>
			<cac:AwardingTerms>
				<cac:AwardingCriterion>
					<cbc:AwardingCriterionTypeCode listName="award-criterion-type">quality</cbc:AwardingCriterionTypeCode>
					<cbc:Description languageID="FRA">Qualité de service jugée au regard du mémoire technique</cbc:Description>
				</cac:AwardingCriterion>
				<cac:AwardingCriterion>
					<cbc:AwardingCriterionTypeCode listName="award-criterion-type">price</cbc:AwardingCriterionTypeCode>
					<cbc:Description languageID="FRA">Montant de la compensation financière, et part variable de la redevance d'occupation du domaine public</cbc:Description>
				</cac:AwardingCriterion>
			</cac:AwardingTerms>
			<cac:AdditionalInformationParty>
				<cac:PartyIdentification>
					<cbc:ID schemeName="organisation">ORG-0001</cbc:ID>
				</cac:PartyIdentification>
			</cac:AdditionalInformationParty>
			<cac:TenderRecipientParty>
				<cbc:EndpointID>http://www.pro-marchespublics.com</cbc:EndpointID>
				<cac:PartyIdentification>
					<cbc:ID schemeName="organisation">ORG-0001</cbc:ID>
				</cac:PartyIdentification>
			</cac:TenderRecipientParty>
			<cac:AppealTerms>
				<cac:PresentationPeriod>
					<cbc:Description languageID="FRA">Un appel...</cbc:Description>
				</cac:PresentationPeriod>
				<cac:AppealReceiverParty>
					<cac:PartyIdentification>
						<cbc:ID schemeName="organization">ORG-0002</cbc:ID>
					</cac:PartyIdentification>
				</cac:AppealReceiverParty>
				<cac:MediationParty>
					<cac:PartyIdentification>
						<cbc:ID schemeName="organization">ORG-0003</cbc:ID>
					</cac:PartyIdentification>
				</cac:MediationParty>
			</cac:AppealTerms>
			<cac:Language>
				<cbc:ID>FRA</cbc:ID>
			</cac:Language>
		</cac:TenderingTerms>
		<cac:TenderingProcess>
			<cbc:GovernmentAgreementConstraintIndicator>false</cbc:GovernmentAgreementConstraintIndicator>
			<cac:TenderSubmissionDeadlinePeriod>
				<cbc:EndDate>2020-07-01+01:00</cbc:EndDate>
				<cbc:EndTime>16:30:00+01:00</cbc:EndTime>
			</cac:TenderSubmissionDeadlinePeriod>
		</cac:TenderingProcess>
		<cac:ProcurementProject>
			<cbc:ID> Dsp crèches</cbc:ID>
			<cbc:Name languageID="FRA">Concession de service public pour la gestion des équipements d'accueil collectif de la petite enfance — secteur nord-est Loches et Tauxigny-Saint-Bauld</cbc:Name>
			<cbc:Description languageID="FRA">— la présente concession de service sous-forme de DSP concerne deux structures de type multi-accueils de quarante berceaux chacune.</cbc:Description>
			<cbc:ProcurementTypeCode listName="contract-nature">services</cbc:ProcurementTypeCode>
			<cac:MainCommodityClassification>
				<cbc:ItemClassificationCode listName="cpv">85312110</cbc:ItemClassificationCode>
			</cac:MainCommodityClassification>
			<cac:RealizedLocation>
				<cac:Address>
					<cbc:CountrySubentityCode listName="nuts">FRB04</cbc:CountrySubentityCode>
				</cac:Address>
			</cac:RealizedLocation>
			<cac:PlannedPeriod>
				<cbc:DurationMeasure unitCode="MONTH">48</cbc:DurationMeasure>
			</cac:PlannedPeriod>
		</cac:ProcurementProject>
	</cac:ProcurementProjectLot>
</ContractNotice>


text:
// Code generated by lister-gen. DO NOT EDIT.

package v1alpha1

// ResolutionRequestListerExpansion allows custom methods to be added to
// ResolutionRequestLister.
type ResolutionRequestListerExpansion interface{}

// ResolutionRequestNamespaceListerExpansion allows custom methods to be added to
// ResolutionRequestNamespaceLister.
type ResolutionRequestNamespaceListerExpansion interface{}

redpajama_set_name: RedPajamaGithub


text:
import notCommon from '../common';
import notBase from '../notBase';
import OPTS from './options';
const META_CACHE = Symbol('cache');

class notTemplateCache extends notBase{

	constructor() {
		super();
		this[META_CACHE] = {};
		this.setWorking('loading', []);
		this.hideTemplates();
		this.register();
		return this;
	}

	hideTemplates(){
		let t = document.createElement('style');
		t.innerHTML = OPTS.TEMPLATE_TAG + '{display: none;}';
		document.head.appendChild(t);
	}

	register() {
		notCommon.register('templateCache', this);
	}

	load(map) {
		this.setWorking('loading', []);
		for (var i in map) {
			this.loadOne(i, map[i]);
		}
	}

	loadOne(key, url, callback) {
		var oRequest = new XMLHttpRequest();
		oRequest.open('GET', url);
		oRequest.addEventListener('load', function(response) {
			var div = document.createElement('DIV');
			div.dataset.notTemplateName = key;
			div.dataset.notTemplateURL = url;
			div.innerHTML = response.srcElement.responseText;
			this.setOne(key, div);
			callback && callback(key, url, div);

		}.bind(this));
		oRequest.send();
	}

	ifAllLoaded(){
		if (this.getWorking('loading').length === 0) {
			this.trigger('loaded');
		}
	}

	setOne(key, element) {
		if(element instanceof HTMLElement){
			this[META_CACHE][key] = element;
		}else{
			this.addFromText(key, element);
		}
	}

	get(key) {
		return this[META_CACHE].hasOwnProperty(key) ? this[META_CACHE][key].cloneNode(true) : null;
	}

	getNames(){
		return Object.keys(this[META_CACHE]);
	}

	getByURL(url) {
		for (var i in this[META_CACHE]) {
			if (this[META_CACHE][i].src == url) {
				return this.get(i);
			}
		}
		return null;
	}
	/*----------------------------------------------------------------------------*/
	//	New API
	/*----------------------------------------------------------------------------*/

	setLoaded(key){
		let t = this.getWorking('loading').indexOf(key);
		if (t > -1) {
			this.getWorking('loading').splice(t, 1);
		}
		this.getWorking('loaded').push('key');
	}

	wrap(key, url, innerHTML){
		var cont = document.createElement(OPTS.TEMPLATE_TAG);
		cont.name = key;
		cont.src = url;
		cont.innerHTML = innerHTML;
		return cont;
	}

	parseLib(text){
		let cont = document.createElement('div');
		let result = {};
		cont.innerHTML = text;
		let notTemplatesElements = cont.querySelectorAll(OPTS.TEMPLATE_TAG);
		for(let elId =0; elId< notTemplatesElements.length; elId++){
			let el = notTemplatesElements[elId];
			if (el.parentNode === cont){
				if (el.attributes.name && el.attributes.name.value){
					result[el.attributes.name.value] = el;
				}
			}
		}
		return result;
	}

	addLib(lib){
		for(let t in lib){
			this.setOne(t, lib[t]);
		}
		return this;
	}

	addFromURL(key, url) {
		return new Promise((resolve, reject)=> {
			if (this.get(key)){
				resolve(this.get(key));
			}else{
				//that.setLoading(key, url);
				notCommon.getHTML(url)
					.then((templateInnerHTML)=>{
						let templateContEl = this.wrap(key, url, templateInnerHTML);
						this.setOne(key, templateContEl);
						resolve(this.get(key));
					}).catch(()=>{
						notCommon.error('error loading template', key, url);
						reject(...arguments);
					});
			}
		});
	}

	addLibFromURL(url) {
		return new Promise((resolve, reject) => {
			notCommon.getHTML(url)
				.then((templatesHTML)=>{
					let templates = this.parseLib(templatesHTML);
					this.addLib(templates);
					resolve(templates);
				}).catch((e)=>{
					notCommon.error('error loading templates lib', url,e);
					reject(...arguments);
				});
		});
	}

	addFromDocument(selectorOrElement){
		let el = (typeof selectorOrElement === 'string')?document.querySelector(selectorOrElement):selectorOrElement;
		if (el.attributes.name && el.attributes.name.value){
			if (el.tagName.toLowerCase() === OPTS.TEMPLATE_TAG.toLowerCase()){
				this.setOne(el.attributes.name.value, el);
			}
		}
		return this;
	}

	addFromText(key, templateInnerHTML){
		let templateContEl = this.wrap(key, '', templateInnerHTML);
		this.setOne(key, templateContEl);
		return this;
	}
}

export default new notTemplateCache();


text:
<?php declare(strict_types = 1);

namespace Mxtb\Api\Lookup\Network;

use Mxtb\Api\AbstractApi;
use Mxtb\Model\Lookup\Network\Trace as Model;

class Trace extends AbstractApi
{
    /**
     * Get the trace status of a domain
     * @param string $domain
     * @param array $headers
     * @return mixed
     */
    public function getTrace(string $domain, array $headers = [])
    {
        $json = $this->get('lookup/trace/' . $domain, $headers);

        return $this->deserialize($json, Model::class);
    }
}


text:
from magi.util.agent import DispatchAgent, agentmethod

# the getAgent() method must be defined somewhere for all agents.
# The Magi daemon invokes this mehod to get a reference to an
# agent. It uses this reference to run and interact with an agent
# instance. (The cotangent() call is generally the same for all agent
# implementations: it just returns an instance of the agent.)
def getAgent():
    return FileCreator()

# The FileCreator agent implementation, derived from DispatchAgent.
class FileCreator(DispatchAgent):
    def __init__(self):
        DispatchAgent.__init__(self)
        self.filename = '/tmp/fuckumagi.txt'

    # A single method which creates the file named by self.filename.
    # (The @agentmethod() decorator is not required, but is encouraged.
    #  it does nothing of substance now, but may in the future.)
    @agentmethod()
    def createFile(self, msg):
        '''Create a file on the host.'''
        # open and immediately close the file to create it.
        open(self.filename, 'w').close()
	return True


text:
package com.blade.mvc.handler;

import com.blade.mvc.WebContext;
import com.blade.mvc.http.Request;
import com.blade.mvc.http.Response;

/**
 * Request Handler
 *
 * @author biezhi
 * @date 2018/6/29
 */
@FunctionalInterface
public interface RequestHandler {

    void handle(WebContext webContext) throws Exception;

}


text:
/*
 * JBox2D - A Java Port of Erin Catto's Box2D
 *
 * JBox2D homepage: http://jbox2d.sourceforge.net/
 * Box2D homepage: http://www.box2d.org
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */

package org.jbox2d.dynamics;

import org.jbox2d.collision.MassData;
import org.jbox2d.collision.Shape;
import org.jbox2d.collision.ShapeDef;
import org.jbox2d.common.*;
import org.jbox2d.dynamics.contacts.ContactEdge;
import org.jbox2d.dynamics.joints.JointEdge;

// Updated to rev. 54->118 of b2Body.cpp/.h
// Rewritten completely for rev. 118 (too many changes, needed reorganization for maintainability)

public class Body {

	//m_flags
	public static final int e_frozenFlag = 0x0002;
	public static final int e_islandFlag = 0x0004;
	public static final int e_sleepFlag = 0x0008;
	public static final int e_allowSleepFlag = 0x0010;
	public static final int e_bulletFlag = 0x0020;
	public static final int e_fixedRotationFlag = 0x0040;
	public int m_flags;

	//m_type
	public static final int e_staticType = 0;
	public static final int e_dynamicType = 1;
	public static final int e_maxTypes = 2;
	public int m_type;

	/** The body origin transform */
	public XForm m_xf;

	/** The swept motion for CCD */
	public Sweep m_sweep;

	public Vec2 m_linearVelocity;
	public float m_angularVelocity;

	public Vec2 m_force;
	public float m_torque;

	public World m_world;
	public Body m_prev;
	public Body m_next;

	public Shape m_shapeList;
	public int m_shapeCount;

	public JointEdge m_jointList;
	public ContactEdge m_contactList;

	public float m_mass, m_invMass;
	public float m_I, m_invI;

	public float m_linearDamping;
	public float m_angularDamping;

	public float m_sleepTime;

	/**
	 * A holder to attach external data to a body.
	 * Useful to keep track of what game entity
	 * each body represents. This is copied from
	 * the BodyDef used to create the body, so may
	 * be set there instead.
	 */
	public Object m_userData;

	/**
	 * Should not be called by user, as it will not
	 * be properly added to the world.  Instead,
	 * create a BodyDef object and pass it
	 * to World.createDynamicBody or World.createStaticBody.
	 *
	 * @param bd Body definition
	 * @param type Body.e_dynamicType or Body.e_staticType
	 * @param world World to create body in
	 */
	public Body(BodyDef bd, int type, World world) {
		assert(world.m_lock == false);
		assert(type < e_maxTypes);

		m_flags = 0;

		if (bd.isBullet) m_flags |= e_bulletFlag;
		if (bd.fixedRotation) m_flags |= e_fixedRotationFlag;
		if (bd.allowSleep) m_flags |= e_allowSleepFlag;
		if (bd.isSleeping) m_flags |= e_sleepFlag;

		m_type = type;

		m_world = world;

		m_xf = new XForm();

		m_xf.position.set(bd.position);
		m_xf.R.set(bd.angle);

		m_sweep = new Sweep();
		m_sweep.localCenter.set(bd.massData.center);
		m_sweep.t0 = 1.0f;
		m_sweep.a0 = m_sweep.a = bd.angle;
		m_sweep.c.set(XForm.mul(m_xf, m_sweep.localCenter));
		m_sweep.c0.set(m_sweep.c);

		m_jointList = null;
		m_contactList = null;
		m_prev = null;
		m_next = null;

		m_linearDamping = bd.linearDamping;
		m_angularDamping = bd.angularDamping;

		m_force = new Vec2(0.0f, 0.0f);
		m_torque = 0.0f;

		m_linearVelocity = new Vec2(0.0f, 0.0f);
		m_angularVelocity = 0.0f;

		m_sleepTime = 0.0f;

		m_mass = 0.0f;
		m_invMass = 0.0f;
		m_I = 0.0f;
		m_invI = 0.0f;

		if (m_type == e_dynamicType) {
			m_mass = bd.massData.mass;
		}

		if (m_mass > 0.0f) {
			m_invMass = 1.0f / m_mass;
		}

		if ((m_flags & Body.e_fixedRotationFlag) == 0 &&
				m_type == e_dynamicType) {
			m_I = bd.massData.I;
		}

		if (m_I > 0.0f) {
			m_invI = 1.0f / m_I;
		}

		m_userData = bd.userData;

		m_shapeList = null;
		m_shapeCount = 0;

	}

	/**
	 *  Creates a shape and attach it to this body.
	 *
Warning: This function is locked during callbacks.
	 * @param def the shape definition.
	 */
	public Shape createShape(ShapeDef def){
		assert(m_world.m_lock == false);

		if (m_world.m_lock == true){
			return null;
		}

		Shape s = Shape.create(def);

		s.m_next = m_shapeList;
		m_shapeList = s;
		++m_shapeCount;

		s.m_body = this;

		// Add the shape to the world's broad-phase.
		s.createProxy(m_world.m_broadPhase, m_xf);

		// Compute the sweep radius for CCD.
		s.updateSweepRadius(m_sweep.localCenter);

		return s;
	}

	/**
	 * Destroy a shape. This removes the shape from the broad-phase and
	 * therefore destroys any contacts associated with this shape. All shapes
	 * attached to a body are implicitly destroyed when the body is destroyed.
	 *
Warning: This function is locked during callbacks.
	 * @param s the shape to be removed.
	 */
	public void destroyShape(Shape s){
		assert(m_world.m_lock == false);
		if (m_world.m_lock == true) {
			return;
		}

		assert(s.m_body == this);
		s.destroyProxy(m_world.m_broadPhase);

		assert(m_shapeCount > 0);

		// Remove s from linked list, fix up connections
		// TODO: verify that this works right
		Shape node = m_shapeList;
		Shape prevNode = null;
		boolean found = false;
		while (node != null) {
			if (node == s) {
				if (prevNode == null) {
					m_shapeList = s.m_next;
					found = true;
					break;
				} else {
					prevNode.m_next = s.m_next;
					found = true;
					break;
				}
			}
			prevNode = node;
			node = node.m_next;
		}
		/*
		Shape** node = &m_shapeList;
		boolean found = false;
		while (*node != NULL)
		{
			if (*node == s)
			{
				*node = s->m_next;
				found = true;
				break;
			}

			node = &(*node)->m_next;
		}
		*/

		// You tried to remove a shape that is not attached to this body.
		assert(found);

		s.m_body = null;
		s.m_next = null;

		--m_shapeCount;
		Shape.destroy(s);
	}

	/**
	 * Set the mass properties. Note that this changes the center of mass position.
	 * If you are not sure how to compute mass properties, use setMassFromShapes().
	 * The inertia tensor is assumed to be relative to the center of mass.
	 * @param massData the mass properties.
	 */
	public void setMass(MassData massData){
		assert(m_world.m_lock == false);
		if (m_world.m_lock == true) return;

		if (m_type == e_staticType) return;

		m_mass = 0.0f;
		m_invMass = 0.0f;
		m_I = 0.0f;
		m_invI = 0.0f;

		m_mass = massData.mass;

		if (m_mass > 0.0f) {
			m_invMass = 1.0f / m_mass;
		}

		if ((m_flags & Body.e_fixedRotationFlag) == 0) {
			m_I = massData.I;
		}

		if (m_I > 0.0f) {
			m_invI = 1.0f / m_I;
		}

		// Move center of mass.
		m_sweep.localCenter.set(massData.center);
		m_sweep.c.set(XForm.mul(m_xf, m_sweep.localCenter));
		m_sweep.c0.set(m_sweep.c);

		// Update the sweep radii of all child shapes
		for (Shape s = m_shapeList; s != null; s = s.m_next) {
			s.updateSweepRadius(m_sweep.localCenter);
		}
	}

	/**
	 * Compute the mass properties from the attached shapes. You typically call this
	 * after adding all the shapes. If you add or remove shapes later, you may want
	 * to call this again. Note that this changes the center of mass position.
	 */
	public void setMassFromShapes(){
		assert(m_world.m_lock == false);
		if (m_world.m_lock == true) return;
		if (m_type == e_staticType) return;

		// Compute mass data from shapes.  Each shape has its own density.
		m_mass = 0.0f;
		m_invMass = 0.0f;
		m_I = 0.0f;
		m_invI = 0.0f;

		Vec2 center = new Vec2(0.0f, 0.0f);
		for (Shape s = m_shapeList; s != null; s = s.m_next) {
			MassData massData = new MassData();
			s.computeMass(massData);
			m_mass += massData.mass;
			center.x += massData.mass * massData.center.x;
			center.y += massData.mass * massData.center.y;
			m_I += massData.I;
		}

		// Compute center of mass, and shift the origin to the COM
		if (m_mass > 0.0f) {
			m_invMass = 1.0f / m_mass;
			center.x *= m_invMass;
			center.y *= m_invMass;
		} else {
			m_invMass = 0.0f;
			m_invI = 0.0f;
		}

		if (m_I > 0.0f && (m_flags & e_fixedRotationFlag) == 0) {
			// Center the inertia about the center of mass
			m_I -= m_mass * Vec2.dot(center, center);
			assert(m_I > 0.0f);
			m_invI = 1.0f / m_I;
		} else {
			m_I = 0.0f;
			m_invI = 0.0f;
		}

		// Move center of mass
		m_sweep.localCenter.set(center);
		m_sweep.c.set(XForm.mul(m_xf, m_sweep.localCenter));
		m_sweep.c0.set(m_sweep.c);

		// Update the sweep radii of all child shapes
		for (Shape s = m_shapeList; s != null; s = s.m_next) {
			s.updateSweepRadius(m_sweep.localCenter);
		}
	}

	/**
	 * Set the position of the body's origin and rotation (radians).
	 * This breaks any contacts and wakes the other bodies.
	 * @param position the new world position of the body's origin (not necessarily
	 * the center of mass).
	 * @param angle the new world rotation angle of the body in radians.
	 * @return false if the movement put a shape outside the world. In this case the
	 * body is automatically frozen.
	 */
	public boolean setXForm(Vec2 position, float angle){
		assert(m_world.m_lock == false);
		if (m_world.m_lock == true) return true;
		if (isFrozen())	return false;

		m_xf.R.set(angle);
		m_xf.position.set(position);

		m_sweep.c.set(XForm.mul(m_xf, m_sweep.localCenter));
		m_sweep.c0.set(m_sweep.c);
		m_sweep.a0 = m_sweep.a = angle;

		boolean freeze = false;

		for (Shape s = m_shapeList; s != null; s = s.m_next) {
			boolean inRange = s.synchronize(m_world.m_broadPhase, m_xf, m_xf);

			if (inRange == false) {
				freeze = true;
				break;
			}
		}

		if (freeze == true) {
			m_flags |= e_frozenFlag;
			m_linearVelocity.setZero();
			m_angularVelocity = 0.0f;
			for (Shape s = m_shapeList; s != null; s = s.m_next) {
				s.destroyProxy(m_world.m_broadPhase);
			}

			// Failure
			return false;
		}

		// Success
		m_world.m_broadPhase.commit();

		return true;
	}

	/**
	 * Get a copy of the body transform for the body's origin.
	 * @return the world transform of the body's origin.
	 */
	public XForm getXForm(){
		XForm xf = new XForm();
		xf.set(m_xf);
		return xf;
	}

	/**
	 * Get a copy of the world body origin position.  This
	 * is not necessarily the same as the center of mass.
	 * @return the world position of the body's origin.
	 */
	public Vec2 getPosition(){
		return m_xf.position.clone();
	}

	/**
	 * Get the angle in radians.
	 * @return the current world rotation angle in radians.
	 */
	public float getAngle(){
		return m_sweep.a;
	}

	/** Get a copy of the world position of the center of mass. */
	public Vec2 getWorldCenter(){
		return m_sweep.c.clone();
	}

	/** Get a copy of the local position of the center of mass. */
	public Vec2 getLocalCenter(){
		return m_sweep.localCenter.clone();
	}

	/**
	 * Set the linear velocity of the center of mass.
	 * @param v the new linear velocity of the center of mass.
	 */
	public void setLinearVelocity(Vec2 v){
		m_linearVelocity.set(v);
	}

	/**
	 * Get a copy of the linear velocity of the center of mass.
	 * @return the linear velocity of the center of mass.
	 */
	public Vec2 getLinearVelocity(){
		return m_linearVelocity.clone();
	}

	/**
	 * Set the angular velocity.
	 * @param omega the new angular velocity in radians/second.
	 */
	public void setAngularVelocity(float omega){
		m_angularVelocity = omega;
	}

	/**
	 * Get the angular velocity.
	 * @return the angular velocity in radians/second.
	 */
	public float getAngularVelocity(){
		return m_angularVelocity;
	}

	/**
	 * Apply a force at a world point. If the force is not
	 * applied at the center of mass, it will generate a torque and
	 * affect the angular velocity. This wakes up the body.
	 * @param force the world force vector, usually in Newtons (N).
	 * @param point the world position of the point of application.
	 */
	public void applyForce(Vec2 force, Vec2 point){
		if (isSleeping()) wakeUp();
		m_force.addLocal(force);
		m_torque += Vec2.cross(point.sub(m_sweep.c), force);
	}

	/**
	 * Apply a torque. This affects the angular velocity
	 * without affecting the linear velocity of the center of mass.
	 * This wakes up the body.
	 * @param torque about the z-axis (out of the screen), usually in N-m.
	 */
	public void applyTorque(float torque){
		if (isSleeping()) wakeUp();
		m_torque += torque;
	}

	/**
	 * Apply an impulse at a point. This immediately modifies the velocity.
	 * It also modifies the angular velocity if the point of application
	 * is not at the center of mass. This wakes up the body.
	 * @param impulse the world impulse vector, usually in N-seconds or kg-m/s.
	 * @param point the world position of the point of application.
	 */
	public void applyImpulse(Vec2 impulse, Vec2 point){
		if (isSleeping()) wakeUp();
		m_linearVelocity.x += m_invMass * impulse.x;
		m_linearVelocity.y += m_invMass * impulse.y;
		m_angularVelocity += m_invI * Vec2.cross(point.sub(m_sweep.c), impulse);
	}

	/**
	 * Get the total mass of the body.
	 * @return the mass, usually in kilograms (kg).
	 */
	public float getMass(){
		return m_mass;
	}

	/**
	 * Get the central rotational inertia of the body.
	 * @return the rotational inertia, usually in kg-m^2.
	 */
	public float getInertia(){
		return m_I;
	}

	/**
	 * Get the world coordinates of a point given the local coordinates.
	 * @param localPoint a point on the body measured relative the the body's origin.
	 * @return the same point expressed in world coordinates.
	 */
	public Vec2 getWorldPoint(Vec2 localPoint){
		return XForm.mul(m_xf, localPoint);
	}

	/**
	 * Get the world coordinates of a vector given the local coordinates.
	 * @param localVector a vector fixed in the body.
	 * @return the same vector expressed in world coordinates.
	 */
	public Vec2 getWorldVector(Vec2 localVector){
		return Mat22.mul(m_xf.R, localVector);
	}

	/**
	 * Gets a local point relative to the body's origin given a world point.
	 * @param worldPoint a point in world coordinates.
	 * @return the corresponding local point relative to the body's origin.
	 */
	public Vec2 getLocalPoint(Vec2 worldPoint){
		return XForm.mulT(m_xf, worldPoint);
	}

	/**
	 * Gets a local vector given a world vector.
	 * @param worldVector a vector in world coordinates.
	 * @return the corresponding local vector.
	 */
	public Vec2 getLocalVector(Vec2 worldVector){
		return Mat22.mulT(m_xf.R, worldVector);
	}

	/** Is this body treated like a bullet for continuous collision detection? */
	public boolean isBullet(){
		return (m_flags & e_bulletFlag) == e_bulletFlag;
	}

	/**
	 * Should this body be treated like a bullet for continuous collision detection?
	 * Use sparingly, as continuous collision detection can be expensive.
	 */
	public void setBullet(boolean flag){
		if (flag) {
			m_flags |= e_bulletFlag;
		} else {
			m_flags &= ~e_bulletFlag;
		}
	}

	/** Is this body static (immovable)? */
	public boolean isStatic(){
		return m_type == e_staticType;
	}

	/** Is this body dynamic (movable)? */
	public boolean isDynamic(){
		return m_type == e_dynamicType;
	}

	/** Is this body frozen? */
	public boolean isFrozen(){
		return (m_flags & e_frozenFlag) == e_frozenFlag;
	}

	/** Is this body sleeping (not simulating). */
	public boolean isSleeping(){
		return (m_flags & e_sleepFlag) == e_sleepFlag;
	}

	/** Set to false to prevent this body from sleeping due to inactivity. */
	public void allowSleeping(boolean flag){
		if (flag) {
			m_flags |= e_allowSleepFlag;
		} else {
			m_flags &= ~e_allowSleepFlag;
			wakeUp();
		}
	}

	/** Wake up this body so it will begin simulating. */
	public void wakeUp(){
		m_flags &= ~e_sleepFlag;
		m_sleepTime = 0.0f;
	}

	/**
	 * Get the linked list of all shapes attached to this body.
	 * @return first Shape in linked list
	 */
	public Shape getShapeList(){
		return m_shapeList;
	}

	/**
	 * Get the linked list of all joints attached to this body.
	 * @return first JointEdge in linked list
	 */
	public JointEdge getJointList(){
		return m_jointList;
	}

	/**
	 * Get the linked list of all contacts attached to this body.
	 * @return first ContactEdge in linked list
	 */
	public ContactEdge getContactList(){
		return m_contactList;
	}

	/** Get the next body in the world's body list. */
	public Body getNext(){
		return m_next;
	}

	/** Get the user data Object reference that was provided in the body definition. */
	public Object getUserData(){
		return m_userData;
	}

	/* INTERNALS BELOW */

	/** For internal use only. */
	public void computeMass(){
		//seems to be missing from C++ version...
	}

	/** For internal use only. */
	public boolean synchronizeShapes(){
		XForm xf1 = new XForm();
		xf1.R.set(m_sweep.a0);
		xf1.position.set(m_sweep.c0.sub(Mat22.mul(xf1.R, m_sweep.localCenter)));

		boolean inRange = true;
		for (Shape s = m_shapeList; s != null; s = s.m_next) {
			inRange = s.synchronize(m_world.m_broadPhase, xf1, m_xf);
			if (inRange == false) break;
		}

		if (inRange == false) {
			m_flags |= e_frozenFlag;
			m_linearVelocity.setZero();
			m_angularVelocity = 0.0f;
			for (Shape s = m_shapeList; s != null; s = s.m_next) {
				s.destroyProxy(m_world.m_broadPhase);
			}

			// Failure
			return false;
		}

		// Success
		return true;
	}

	/** For internal use only. */
	public void synchronizeTransform(){
		m_xf.R.set(m_sweep.a);
		m_xf.position.set(m_sweep.c.sub(Mat22.mul(m_xf.R,m_sweep.localCenter)));
		//System.out.println(m_xf);
	}

	/**
	 * This is used to prevent connected bodies from colliding.
	 * It may lie, depending on the collideConnected flag, so
	 * it won't be very useful external to the engine.
	 */
	public boolean isConnected(Body other){
		for (JointEdge jn = m_jointList; jn != null; jn = jn.next) {
			if (jn.other == other) {
				//System.out.println("connected");
				return (jn.joint.m_collideConnected == false);
			}
		}
		return false;
	}

	/** For internal use only. */
	public void advance(float t){
		// Advance to the new safe time
		m_sweep.advance(t);
		m_sweep.c.set(m_sweep.c0);
		m_sweep.a = m_sweep.a0;
		synchronizeTransform();
	}

}


text:
require 'rails_ember_templates/template'
require 'sprockets/railtie'

module RailsEmberTemplates
  class Engine < ::Rails::Engine
    config.handlebars = ActiveSupport::OrderedOptions.new

    config.handlebars.precompile = true
    config.handlebars.templates_root = "templates"
    config.handlebars.templates_path_separator = '/'
    config.handlebars.output_type = :global

    config.before_initialize do |app|
      Sprockets::Engines #force autoloading
      Sprockets.register_engine '.handlebars', RailsEmberTemplates::Template
      Sprockets.register_engine '.hbs', RailsEmberTemplates::Template
      Sprockets.register_engine '.hjs', RailsEmberTemplates::Template
    end
  end
end


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Arthonia asteriscus Müll. Arg.

### Remarks
null


text:
\begin{figure}[H]
\centering
\includegraphics[width=6in]{figs/run_10/run_10_ctke_05rdynamic}
\caption{Plot showing dynamic variations in turbulent kinetic energy between 0 and 0.5 core radii. $z/c$=5.37, $V_{free}$=32.98, station 1.}
\label{fig:run_10_ctke_05rdynamic}
\end{figure}


text:
/**
 * Created by Claire on 2015/7/23.
 */
var gulp = require('gulp');
var path = require('path');
var fs = require('fs');
var config = require('./config.js');
var defaultConfig = require('./webpack.defaults.js');

if (config.webpackConfig) {
    if (config.webpackConfig.debug) {
        config.webpackConfig.debug = defaultConfig(config.webpackConfig.debug);
    }
    if (config.webpackConfig.production) {
        config.webpackConfig.production = defaultConfig(config.webpackConfig.production);
    }
}
var tasksPath = path.join(__dirname, 'tasks');
var tasks = fs.readdirSync(tasksPath).map(function(file) { return file.replace('.js', ''); });

tasks.forEach(function(file) {
    var task = require(tasksPath+'/' + file).bind(this, config);
    if (task.deps) {
        gulp.task(file, task.deps, task.work);
    } else {
        gulp.task(file, task);
    }
});

/*gulp.task('debug',function(){
    var task = require('./tasks/debug.js').bind(this, config);
    gulp.task('debug', task);
});
gulp.task('serve',function(){
    var task = require('./tasks/serve.js').bind(this, config);
    gulp.task('serve', task);
});*/
gulp.task('assets', function() {
    return gulp.src('./index.html').pipe(gulp.dest('./dist'));
});
gulp.task('default', ['debug', 'serve']);
gulp.task('deploy', ['build', 'assets']);


text:
package com.facebook.imagepipeline.animated.base;

import java.util.concurrent.ScheduledExecutorService;

import android.animation.ValueAnimator;
import android.annotation.TargetApi;
import android.os.Build;
import android.view.animation.LinearInterpolator;

import com.facebook.common.time.MonotonicClock;

/**
 * A {@link Drawable} that renders a animated image. The details of the format are abstracted by the
 * {@link AnimatedDrawableBackend} interface. The drawable can work either as an {@link Animatable}
 * where the client calls start/stop to animate it or it can work as a level-based drawable where
 * the client drives the animation by calling {@link Drawable#setLevel}.
 */

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public class AnimatedDrawable extends AbstractAnimatedDrawable implements AnimatableDrawable {

  public AnimatedDrawable(
      ScheduledExecutorService scheduledExecutorServiceForUiThread,
      AnimatedDrawableCachingBackend animatedDrawableBackend,
      AnimatedDrawableDiagnostics animatedDrawableDiagnostics,
      MonotonicClock monotonicClock) {
    super(scheduledExecutorServiceForUiThread,
        animatedDrawableBackend,
        animatedDrawableDiagnostics,
        monotonicClock);
  }

  @Override
  public ValueAnimator createValueAnimator(int maxDurationMs) {
    ValueAnimator animator = createValueAnimator();
    int repeatCount = Math.max((maxDurationMs / getAnimatedDrawableBackend().getDurationMs()), 1);
    animator.setRepeatCount(repeatCount);
    return animator;
  }

  @Override
  public ValueAnimator createValueAnimator() {
    int loopCount = getAnimatedDrawableBackend().getLoopCount();
    ValueAnimator animator = new ValueAnimator();
    animator.setIntValues(0, getDuration());
    animator.setDuration(getDuration());
    animator.setRepeatCount(loopCount != 0 ? loopCount : ValueAnimator.INFINITE);
    animator.setRepeatMode(ValueAnimator.RESTART);
    animator.setInterpolator(new LinearInterpolator());
    animator.addUpdateListener(createAnimatorUpdateListener());
    return animator;
  }

  @Override
  public ValueAnimator.AnimatorUpdateListener createAnimatorUpdateListener() {
    return new ValueAnimator.AnimatorUpdateListener() {
      @Override
      public void onAnimationUpdate(ValueAnimator animation) {
        setLevel((Integer) animation.getAnimatedValue());
      }
    };
  }

}


text:
package volman_test

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"time"

	"code.cloudfoundry.org/auction/auctiontypes"
	"code.cloudfoundry.org/bbs"
	"code.cloudfoundry.org/bbs/models"
	"code.cloudfoundry.org/inigo/helpers"
	"code.cloudfoundry.org/lager"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	"github.com/tedsuo/ifrit"
	"github.com/tedsuo/ifrit/ginkgomon"
	"github.com/tedsuo/ifrit/grouper"

	archive_helper "code.cloudfoundry.org/archiver/extractor/test_helper"
	"code.cloudfoundry.org/inigo/fixtures"
)

var _ = Describe("LRPs with volume mounts", func() {
	var (
		cellProcess         ifrit.Process
		fileServerStaticDir string
		plumbing            ifrit.Process
		logger              lager.Logger
		bbsClient           bbs.InternalClient
		processGuid         string
		archiveFiles        []archive_helper.ArchiveFile
	)

	BeforeEach(func() {
		var fileServerRunner ifrit.Runner
		fileServerRunner, fileServerStaticDir = componentMaker.FileServer()
		plumbing = ginkgomon.Invoke(grouper.NewOrdered(os.Kill, grouper.Members{
			{"initial-services", grouper.NewParallel(os.Kill, grouper.Members{
				{"sql", componentMaker.SQL()},
				{"nats", componentMaker.NATS()},
				{"consul", componentMaker.Consul()},
			})},
			{"locket", componentMaker.Locket()},
			{"bbs", componentMaker.BBS()},
		}))

		helpers.ConsulWaitUntilReady(componentMaker.Addresses())
		logger = lager.NewLogger("test")
		logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))

		cellProcess = ginkgomon.Invoke(grouper.NewParallel(os.Kill, grouper.Members{
			{"router", componentMaker.Router()},
			{"file-server", fileServerRunner},
			{"rep", componentMaker.Rep()},
			{"auctioneer", componentMaker.Auctioneer()},
			{"route-emitter", componentMaker.RouteEmitter()},
		}))

		bbsServiceClient := componentMaker.BBSServiceClient(logger)
		bbsClient = componentMaker.BBSClient()
		archiveFiles = fixtures.GoServerApp()

		Eventually(func() (models.CellSet, error) { return bbsServiceClient.Cells(logger) }).Should(HaveLen(1))
	})

	JustBeforeEach(func() {
		archive_helper.CreateZipArchive(
			filepath.Join(fileServerStaticDir, "lrp.zip"),
			archiveFiles,
		)
	})

	AfterEach(func() {
		destroyContainerErrors := helpers.CleanupGarden(gardenClient)
		helpers.StopProcesses(plumbing, cellProcess)
		Expect(destroyContainerErrors).To(
			BeEmpty(),
			"%d containers failed to be destroyed!",
			len(destroyContainerErrors),
		)
	})

	Describe("desiring with volume mount", func() {
		var lrp *models.DesiredLRP

		BeforeEach(func() {
			processGuid = helpers.GenerateGuid()

			volumeId := fmt.Sprintf("some-volumeID-%d", time.Now().UnixNano())
			someConfig := map[string]interface{}{"volume_id": volumeId}
			jsonSomeConfig, err := json.Marshal(someConfig)
			Expect(err).NotTo(HaveOccurred())

			lrp = helpers.DefaultLRPCreateRequest(componentMaker.Addresses(), processGuid, "log-guid", 1)

			lrp.Setup = nil

			lrp.VolumeMounts = []*models.VolumeMount{
				&models.VolumeMount{
					Driver:       "localdriver",
					ContainerDir: "/testmount",
					Mode:         "rw",
					Shared: &models.SharedDevice{
						VolumeId:    volumeId,
						MountConfig: string(jsonSomeConfig),
					},
				},
			}

			lrp.CachedDependencies = []*models.CachedDependency{{
				From:      fmt.Sprintf("http://%s/v1/static/%s", componentMaker.Addresses().FileServer, "lrp.zip"),
				To:        "/tmp/diego",
				Name:      "lrp bits",
				CacheKey:  "lrp-cache-key",
				LogSource: "APP",
			}}

			lrp.Privileged = true

			lrp.Action = models.WrapAction(&models.RunAction{
				User: "vcap",
				Path: "/tmp/diego/go-server",
				Env: []*models.EnvironmentVariable{
					{"PORT", "8080"},
					{"MOUNT_POINT_DIR", "/testmount"},
				},
			})
		})

		JustBeforeEach(func() {
			err := bbsClient.DesireLRP(logger, lrp)
			Expect(err).NotTo(HaveOccurred())
		})

		It("can write to a file on the mounted volume", func() {
			Eventually(helpers.LRPStatePoller(logger, bbsClient, processGuid, nil)).Should(Equal(models.ActualLRPStateRunning))
			Eventually(helpers.HelloWorldInstancePoller(componentMaker.Addresses().Router, helpers.DefaultHost)).Should(ConsistOf([]string{"0"}))
			body, statusCode, err := helpers.ResponseBodyAndStatusCodeFromHost(componentMaker.Addresses().Router, helpers.DefaultHost, "write")
			Expect(err).NotTo(HaveOccurred())
			Expect(string(body)).To(Equal("Hello Persistant World!\n"))
			Expect(statusCode).To(Equal(200))
		})

		Context("when driver required not available on any cell", func() {
			BeforeEach(func() {
				lrp.VolumeMounts = []*models.VolumeMount{
					generateVolumeObject("non-existent-driver"),
				}
			})

			It("should error placing the lrp", func() {
				var actualLRP *models.ActualLRP
				Eventually(func() interface{} {
					index := int32(0)
					lrps, err := bbsClient.ActualLRPs(logger, models.ActualLRPFilter{ProcessGuid: processGuid, Index: &index})
					Expect(err).NotTo(HaveOccurred())
					Expect(len(lrps)).To(Equal(1))
					Expect(lrps[0].Presence).NotTo(Equal(models.ActualLRP_Evacuating))
					actualLRP = lrps[0]

					return actualLRP.PlacementError
				}).Should(Equal(auctiontypes.ErrorVolumeDriverMismatch.Error()))
			})
		})

		Context("when one of the drivers required is not available on any cell", func() {
			BeforeEach(func() {
				lrp.VolumeMounts = []*models.VolumeMount{
					generateVolumeObject("non-existent-driver"),
					generateVolumeObject("localdriver"),
				}
			})

			It("should error placing the task", func() {
				var actualLRP *models.ActualLRP
				Eventually(func() interface{} {
					index := int32(0)
					lrps, err := bbsClient.ActualLRPs(logger, models.ActualLRPFilter{ProcessGuid: processGuid, Index: &index})
					Expect(err).NotTo(HaveOccurred())
					Expect(len(lrps)).To(Equal(1))
					Expect(lrps[0].Presence).NotTo(Equal(models.ActualLRP_Evacuating))
					actualLRP = lrps[0]

					return actualLRP.PlacementError
				}).Should(Equal(auctiontypes.ErrorVolumeDriverMismatch.Error()))
			})
		})

		Context("when one of the drivers required is on a cell, but not running", func() {
			BeforeEach(func() {
				lrp.VolumeMounts = []*models.VolumeMount{
					generateVolumeObject("deaddriver"),
					generateVolumeObject("localdriver"),
				}
			})

			It("should error placing the task", func() {
				var actualLRP *models.ActualLRP
				Eventually(func() interface{} {
					index := int32(0)
					lrps, err := bbsClient.ActualLRPs(logger, models.ActualLRPFilter{ProcessGuid: processGuid, Index: &index})
					Expect(err).NotTo(HaveOccurred())
					Expect(lrps[0].Presence).NotTo(Equal(models.ActualLRP_Evacuating))
					actualLRP = lrps[0]

					return actualLRP.PlacementError
				}).Should(Equal(auctiontypes.ErrorVolumeDriverMismatch.Error()))
			})
		})
	})
})


text:
class EthernetInfoWidget : public QWidget {
	Q_OBJECT
  public:
	explicit EthernetInfoWidget(
		QWidget *parent, RetSetEthernetPortInfo *m_pRetSetEthernetPortInfo);

	virtual ~EthernetInfoWidget();

  signals:
	void staticBoxDisabled(bool disabled);

  public slots:
	void comboboxSelected(int selected);

  private slots:
	void editFinished(IPAddressInput *input, int flags);
	void updateEthernetConfig();

  private:
	void createWidgets();
	void setupWidgets();
	void setupLayout();
	void setData();
	void createConnections();
	void setStaticBoxEnabled(int selected);
	bool ipAddressControlsValid();

	// Members
  private:
	RetSetEthernetPortInfo *m_pRetSetEthernetPortInfo = nullptr;
	QTimer *r_mUpdateTimer = nullptr;

	QSignalMapper *iPAddressInputSignalMapper = nullptr;

	QRegExpValidator *regValidator = nullptr;

	QGridLayout *m_pRootLayout = nullptr;
	QGridLayout *m_pStaticLayout = nullptr;
	QGridLayout *m_pDhcpLayout = nullptr;
	QGridLayout *m_pInfoLayout = nullptr;

	QLabel *m_pTl = nullptr;
	QLabel *m_pIpl1 = nullptr;
	QLabel *m_pSml1 = nullptr;
	QLabel *m_pGwl1 = nullptr;
	QLabel *m_PIpl2 = nullptr;
	QLabel *m_pSml2 = nullptr;
	QLabel *m_pGwl2 = nullptr;
	QLabel *m_pBjl = nullptr;
	QLabel *m_pMacl = nullptr;

	QComboBox *m_pMethodBox = nullptr;

	QGroupBox *m_pStaticBox = nullptr;
	QGroupBox *m_pDhcpBox = nullptr;
	QGroupBox *m_pInfoBox = nullptr;

	IPAddressInput *m_Ip1 = nullptr;
	IPAddressInput *m_pSm1 = nullptr;
	IPAddressInput *m_pGw1 = nullptr;

	QLineEdit *m_pIp2 = nullptr;
	QLineEdit *m_pSm2 = nullptr;
	QLineEdit *m_pGw2 = nullptr;
	QLineEdit *m_pBj = nullptr;
	QLineEdit *m_pMac = nullptr;

	QWidget *m_pEmpty = nullptr;

	std::vector<IPAddressInput *> *m_pValidateControls;
};

#endif // ETHERNETINFOWIDGET_H


text:
package com.vmware.vim25;

/**
@author Steve Jin (sjin@vmware.com)
*/

public class HostConnectInfoNetworkInfo extends DynamicData
{
  public NetworkSummary summary;

  public NetworkSummary getSummary()
  {
    return this.summary;
  }

  public void setSummary(NetworkSummary summary)
  {
    this.summary=summary;
  }
}


text:
layout: page
title: "Loriliai Biernacki"
comments: true
description: "blanks"
keywords: "Loriliai Biernacki,CU,Boulder"
---
<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
<script src="https://dl.dropboxusercontent.com/s/pc42nxpaw1ea4o9/highcharts.js?dl=0"></script>
<!-- <script src="../assets/js/highcharts.js"></script> -->
<style type="text/css">@font-face {
	font-family: "Bebas Neue";
	src: url(https://www.filehosting.org/file/details/544349/BebasNeue Regular.otf) format("opentype");
	}
	h1.Bebas {
		font-family: "Bebas Neue", Verdana, Tahoma;
	}
</style>
</head>

#### TEACHING INFORMATION

**College**: College of Arts and Sciences

**Classes taught**: RLST 1620, RLST 2610, RLST 2612, RLST 3200, RLST 4200, RLST 4280, RLST 4820

#### RLST 1620: Religious Dimension in Human Experience

**Terms taught**: Fall 2010, Fall 2011, Fall 2012, Spring 2016

**Instructor rating**: 4.37

**Standard deviation in instructor rating**: 0.4

**Average grade** (4.0 scale): 2.8

**Standard deviation in grades** (4.0 scale): 0.11

**Average workload** (raw): 2.29

**Standard deviation in workload** (raw): 0.29

#### RLST 2610: Religions of India

**Terms taught**: Spring 2007, Spring 2008, Spring 2009, Spring 2010, Spring 2011, Spring 2012, Spring 2013, Fall 2015, Spring 2017

**Instructor rating**: 4.81

**Standard deviation in instructor rating**: 0.47

**Average grade** (4.0 scale): 2.94

**Standard deviation in grades** (4.0 scale): 0.1

**Average workload** (raw): 2.39

**Standard deviation in workload** (raw): 0.16

#### RLST 2612: Yoga: Ancient and Modern

**Terms taught**: Fall 2016

**Instructor rating**: 4.56

**Standard deviation in instructor rating**: 0.0

**Average grade** (4.0 scale): 3.07

**Standard deviation in grades** (4.0 scale): 0.0

**Average workload** (raw): 2.01

**Standard deviation in workload** (raw): 0.0

#### RLST 3200: Hinduism

**Terms taught**: Fall 2006, Fall 2008, Fall 2009, Fall 2010, Fall 2011, Fall 2012, Spring 2015, Fall 2016

**Instructor rating**: 4.95

**Standard deviation in instructor rating**: 0.58

**Average grade** (4.0 scale): 2.94

**Standard deviation in grades** (4.0 scale): 0.14

**Average workload** (raw): 2.27

**Standard deviation in workload** (raw): 0.17

#### RLST 4200: Topics in Hinduism

**Terms taught**: Spring 2007, Spring 2009, Spring 2010, Fall 2015

**Instructor rating**: 5.61

**Standard deviation in instructor rating**: 0.16

**Average grade** (4.0 scale): 3.5

**Standard deviation in grades** (4.0 scale): 0.43

**Average workload** (raw): 3.26

**Standard deviation in workload** (raw): 0.24

#### RLST 4280: Body and Magic in India

**Terms taught**: Spring 2017

**Instructor rating**: 5.88

**Standard deviation in instructor rating**: 0.0

**Average grade** (4.0 scale): 3.25

**Standard deviation in grades** (4.0 scale): 0.0

**Average workload** (raw): 2.36

**Standard deviation in workload** (raw): 0.0

#### RLST 4820: Interdisciplinary Seminar on Religion: Topics

**Terms taught**: Fall 2006, Fall 2008, Fall 2009, Spring 2015

**Instructor rating**: 5.4

**Standard deviation in instructor rating**: 0.24

**Average grade** (4.0 scale): 3.57

**Standard deviation in grades** (4.0 scale): 0.14

**Average workload** (raw): 3.47

**Standard deviation in workload** (raw): 0.45


text:
from __future__ import absolute_import, division, print_function
__metaclass__ = type

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'community'}

DOCUMENTATION = r'''
---
module: bigip_monitor_snmp_dca
short_description: Manages BIG-IP SNMP data collecting agent (DCA) monitors
description:
  - The BIG-IP has an SNMP data collecting agent (DCA) that can query remote
    SNMP agents of various types, including the UC Davis agent (UCD) and the
    Windows 2000 Server agent (WIN2000).
version_added: "2.5"
options:
  name:
    description:
      - Monitor name.
    required: True
    aliases:
      - monitor
  description:
    description:
      - Specifies descriptive text that identifies the monitor.
  parent:
    description:
      - The parent template of this monitor template. Once this value has
        been set, it cannot be changed. By default, this value is the C(snmp_dca)
        parent on the C(Common) partition.
    default: "/Common/snmp_dca"
  interval:
    description:
      - Specifies, in seconds, the frequency at which the system issues the
        monitor check when either the resource is down or the status of the
        resource is unknown. When creating a new monitor, the default is C(10).
  timeout:
    description:
      - Specifies the number of seconds the target has in which to respond to
        the monitor request. When creating a new monitor, the default is C(30)
        seconds. If the target responds within the set time period, it is
        considered 'up'. If the target does not respond within the set time
        period, it is considered 'down'. When this value is set to 0 (zero),
        the system uses the interval from the parent monitor. Note that
        C(timeout) and C(time_until_up) combine to control when a resource is
        set to up.
  time_until_up:
    description:
      - Specifies the number of seconds to wait after a resource first responds
        correctly to the monitor before setting the resource to 'up'. During the
        interval, all responses from the resource must be correct. When the
        interval expires, the resource is marked 'up'. A value of 0, means
        that the resource is marked up immediately upon receipt of the first
        correct response. When creating a new monitor, the default is C(0).
  community:
    description:
      - Specifies the community name that the system must use to authenticate
        with the host server through SNMP. When creating a new monitor, the
        default value is C(public). Note that this value is case sensitive.
  version:
    description:
      - Specifies the version of SNMP that the host server uses. When creating
        a new monitor, the default is C(v1). When C(v1), specifies that the
        host server uses SNMP version 1. When C(v2c), specifies that the host
        server uses SNMP version 2c.
    choices:
      - v1
      - v2c
  agent_type:
    description:
      - Specifies the SNMP agent running on the monitored server. When creating
        a new monitor, the default is C(UCD) (UC-Davis).
    choices:
      - UCD
      - WIN2000
      - GENERIC
  cpu_coefficient:
    description:
      - Specifies the coefficient that the system uses to calculate the weight
        of the CPU threshold in the dynamic ratio load balancing algorithm.
        When creating a new monitor, the default is C(1.5).
  cpu_threshold:
    description:
      - Specifies the maximum acceptable CPU usage on the target server. When
        creating a new monitor, the default is C(80) percent.
  memory_coefficient:
    description:
      - Specifies the coefficient that the system uses to calculate the weight
        of the memory threshold in the dynamic ratio load balancing algorithm.
        When creating a new monitor, the default is C(1.0).
  memory_threshold:
    description:
      - Specifies the maximum acceptable memory usage on the target server.
        When creating a new monitor, the default is C(70) percent.
  disk_coefficient:
    description:
      - Specifies the coefficient that the system uses to calculate the weight
        of the disk threshold in the dynamic ratio load balancing algorithm.
        When creating a new monitor, the default is C(2.0).
  disk_threshold:
    description:
      - Specifies the maximum acceptable disk usage on the target server. When
        creating a new monitor, the default is C(90) percent.
  partition:
    description:
      - Device partition to manage resources on.
    default: Common
notes:
  - Requires the f5-sdk Python package on the host. This is as easy as pip
    install f5-sdk.
  - Requires BIG-IP software version >= 12
  - This module does not support the C(variables) option because this option
    is broken in the REST API and does not function correctly in C(tmsh); for
    example you cannot remove user-defined params. Therefore, there is no way
    to automatically configure it.
requirements:
  - f5-sdk >= 2.2.3
extends_documentation_fragment: f5
author:
  - Tim Rupp (@caphrim007)
'''

EXAMPLES = r'''
- name: Create SNMP DCS monitor
  bigip_monitor_snmp_dca:
    state: present
    server: lb.mydomain.com
    user: admin
    password: secret
    name: my_monitor
  delegate_to: localhost

- name: Remove TCP Echo Monitor
  bigip_monitor_snmp_dca:
    state: absent
    server: lb.mydomain.com
    user: admin
    password: secret
    name: my_monitor
  delegate_to: localhost
'''

RETURN = r'''
parent:
  description: New parent template of the monitor.
  returned: changed
  type: string
  sample: snmp_dca
interval:
  description: The new interval in which to run the monitor check.
  returned: changed
  type: int
  sample: 2
timeout:
  description: The new timeout in which the remote system must respond to the monitor.
  returned: changed
  type: int
  sample: 10
time_until_up:
  description: The new time in which to mark a system as up after first successful response.
  returned: changed
  type: int
  sample: 2
community:
  description: The new community for the monitor.
  returned: changed
  type: string
  sample: foobar
version:
  description: The new new SNMP version to be used by the monitor.
  returned: changed
  type: string
  sample: v2c
agent_type:
  description: The new agent type to be used by the monitor.
  returned: changed
  type: string
  sample: UCD
cpu_coefficient:
  description: The new CPU coefficient.
  returned: changed
  type: float
  sample: 2.4
cpu_threshold:
  description: The new CPU threshold.
  returned: changed
  type: int
  sample: 85
memory_coefficient:
  description: The new memory coefficient.
  returned: changed
  type: float
  sample: 6.4
memory_threshold:
  description: The new memory threshold.
  returned: changed
  type: int
  sample: 50
disk_coefficient:
  description: The new disk coefficient.
  returned: changed
  type: float
  sample: 10.2
disk_threshold:
  description: The new disk threshold.
  returned: changed
  type: int
  sample: 34
'''

import os

from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import AnsibleF5Parameters
from ansible.module_utils.f5_utils import HAS_F5SDK
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.six import iteritems
from collections import defaultdict

try:
    from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
except ImportError:
    HAS_F5SDK = False

class Parameters(AnsibleF5Parameters):
    api_map = {
        'timeUntilUp': 'time_until_up',
        'defaultsFrom': 'parent',
        'agentType': 'agent_type',
        'cpuCoefficient': 'cpu_coefficient',
        'cpuThreshold': 'cpu_threshold',
        'memoryCoefficient': 'memory_coefficient',
        'memoryThreshold': 'memory_threshold',
        'diskCoefficient': 'disk_coefficient',
        'diskThreshold': 'disk_threshold'
    }

    api_attributes = [
        'timeUntilUp', 'defaultsFrom', 'interval', 'timeout', 'destination', 'community',
        'version', 'agentType', 'cpuCoefficient', 'cpuThreshold', 'memoryCoefficient',
        'memoryThreshold', 'diskCoefficient', 'diskThreshold'
    ]

    returnables = [
        'parent', 'ip', 'interval', 'timeout', 'time_until_up', 'description', 'community',
        'version', 'agent_type', 'cpu_coefficient', 'cpu_threshold', 'memory_coefficient',
        'memory_threshold', 'disk_coefficient', 'disk_threshold'
    ]

    updatables = [
        'ip', 'interval', 'timeout', 'time_until_up', 'description', 'community',
        'version', 'agent_type', 'cpu_coefficient', 'cpu_threshold', 'memory_coefficient',
        'memory_threshold', 'disk_coefficient', 'disk_threshold'
    ]

    def __init__(self, params=None):
        self._values = defaultdict(lambda: None)
        self._values['__warnings'] = []
        if params:
            self.update(params=params)

    def update(self, params=None):
        if params:
            for k, v in iteritems(params):
                if self.api_map is not None and k in self.api_map:
                    map_key = self.api_map[k]
                else:
                    map_key = k

                # Handle weird API parameters like `dns.proxy.__iter__` by
                # using a map provided by the module developer
                class_attr = getattr(type(self), map_key, None)
                if isinstance(class_attr, property):
                    # There is a mapped value for the api_map key
                    if class_attr.fset is None:
                        # If the mapped value does not have
                        # an associated setter
                        self._values[map_key] = v
                    else:
                        # The mapped value has a setter
                        setattr(self, map_key, v)
                else:
                    # If the mapped value is not a @property
                    self._values[map_key] = v

    def to_return(self):
        result = {}
        try:
            for returnable in self.returnables:
                result[returnable] = getattr(self, returnable)
            result = self._filter_params(result)
            return result
        except Exception:
            return result

    def api_params(self):
        result = {}
        for api_attribute in self.api_attributes:
            if self.api_map is not None and api_attribute in self.api_map:
                result[api_attribute] = getattr(self, self.api_map[api_attribute])
            else:
                result[api_attribute] = getattr(self, api_attribute)
        result = self._filter_params(result)
        return result

    @property
    def interval(self):
        if self._values['interval'] is None:
            return None
        if 1 > int(self._values['interval']) > 86400:
            raise F5ModuleError(
                "Interval value must be between 1 and 86400"
            )
        return int(self._values['interval'])

    @property
    def timeout(self):
        if self._values['timeout'] is None:
            return None
        return int(self._values['timeout'])

    @property
    def time_until_up(self):
        if self._values['time_until_up'] is None:
            return None
        return int(self._values['time_until_up'])

    @property
    def parent(self):
        if self._values['parent'] is None:
            return None
        if self._values['parent'].startswith('/'):
            parent = os.path.basename(self._values['parent'])
            result = '/{0}/{1}'.format(self.partition, parent)
        else:
            result = '/{0}/{1}'.format(self.partition, self._values['parent'])
        return result

    @property
    def cpu_coefficient(self):
        result = self._get_numeric_property('cpu_coefficient')
        return result

    @property
    def cpu_threshold(self):
        result = self._get_numeric_property('cpu_threshold')
        return result

    @property
    def memory_coefficient(self):
        result = self._get_numeric_property('memory_coefficient')
        return result

    @property
    def memory_threshold(self):
        result = self._get_numeric_property('memory_threshold')
        return result

    @property
    def disk_coefficient(self):
        result = self._get_numeric_property('disk_coefficient')
        return result

    @property
    def disk_threshold(self):
        result = self._get_numeric_property('disk_threshold')
        return result

    def _get_numeric_property(self, property):
        if self._values[property] is None:
            return None
        try:
            fvar = float(self._values[property])
        except ValueError:
            raise F5ModuleError(
                "Provided {0} must be a valid number".format(property)
            )
        return fvar

    @property
    def type(self):
        return 'snmp_dca'

class Difference(object):
    def __init__(self, want, have=None):
        self.want = want
        self.have = have

    def compare(self, param):
        try:
            result = getattr(self, param)
            return result
        except AttributeError:
            result = self.__default(param)
            return result

    @property
    def parent(self):
        if self.want.parent != self.want.parent:
            raise F5ModuleError(
                "The parent monitor cannot be changed"
            )

    @property
    def destination(self):
        if self.want.ip is None:
            return None
        if self.want.destination != self.have.destination:
            return self.want.destination

    @property
    def interval(self):
        if self.want.timeout is not None and self.want.interval is not None:
            if self.want.interval >= self.want.timeout:
                raise F5ModuleError(
                    "Parameter 'interval' must be less than 'timeout'."
                )
        elif self.want.timeout is not None:
            if self.have.interval >= self.want.timeout:
                raise F5ModuleError(
                    "Parameter 'interval' must be less than 'timeout'."
                )
        elif self.want.interval is not None:
            if self.want.interval >= self.have.timeout:
                raise F5ModuleError(
                    "Parameter 'interval' must be less than 'timeout'."
                )
        if self.want.interval != self.have.interval:
            return self.want.interval

    def __default(self, param):
        attr1 = getattr(self.want, param)
        try:
            attr2 = getattr(self.have, param)
            if attr1 != attr2:
                return attr1
        except AttributeError:
            return attr1

class ModuleManager(object):
    def __init__(self, client):
        self.client = client
        self.have = None
        self.want = Parameters(self.client.module.params)
        self.changes = Parameters()

    def _set_changed_options(self):
        changed = {}
        for key in Parameters.returnables:
            if getattr(self.want, key) is not None:
                changed[key] = getattr(self.want, key)
        if changed:
            self.changes = Parameters(changed)

    def _update_changed_options(self):
        diff = Difference(self.want, self.have)
        updatables = Parameters.updatables
        changed = dict()
        for k in updatables:
            change = diff.compare(k)
            if change is None:
                continue
            else:
                changed[k] = change
        if changed:
            self.changes = Parameters(changed)
            return True
        return False

    def _announce_deprecations(self):
        warnings = []
        if self.want:
            warnings += self.want._values.get('__warnings', [])
        if self.have:
            warnings += self.have._values.get('__warnings', [])
        for warning in warnings:
            self.client.module.deprecate(
                msg=warning['msg'],
                version=warning['version']
            )

    def exec_module(self):
        changed = False
        result = dict()
        state = self.want.state

        try:
            if state == "present":
                changed = self.present()
            elif state == "absent":
                changed = self.absent()
        except iControlUnexpectedHTTPError as e:
            raise F5ModuleError(str(e))

        changes = self.changes.to_return()
        result.update(**changes)
        result.update(dict(changed=changed))
        self._announce_deprecations()
        return result

    def present(self):
        if self.exists():
            return self.update()
        else:
            return self.create()

    def create(self):
        self._set_changed_options()

        if self.want.timeout is None:
            self.want.update({'timeout': 30})
        if self.want.interval is None:
            self.want.update({'interval': 10})
        if self.want.time_until_up is None:
            self.want.update({'time_until_up': 0})
        if self.want.community is None:
            self.want.update({'community': 'public'})
        if self.want.version is None:
            self.want.update({'version': 'v1'})
        if self.want.agent_type is None:
            self.want.update({'agent_type': 'UCD'})
        if self.want.cpu_coefficient is None:
            self.want.update({'cpu_coefficient': '1.5'})
        if self.want.cpu_threshold is None:
            self.want.update({'cpu_threshold': '80'})
        if self.want.memory_coefficient is None:
            self.want.update({'memory_coefficient': '1.0'})
        if self.want.memory_threshold is None:
            self.want.update({'memory_threshold': '70'})
        if self.want.disk_coefficient is None:
            self.want.update({'disk_coefficient': '2.0'})
        if self.want.disk_threshold is None:
            self.want.update({'disk_threshold': '90'})

        if self.client.check_mode:
            return True
        self.create_on_device()
        return True

    def should_update(self):
        result = self._update_changed_options()
        if result:
            return True
        return False

    def update(self):
        self.have = self.read_current_from_device()
        if not self.should_update():
            return False
        if self.client.check_mode:
            return True
        self.update_on_device()
        return True

    def absent(self):
        if self.exists():
            return self.remove()
        return False

    def remove(self):
        if self.client.check_mode:
            return True
        self.remove_from_device()
        if self.exists():
            raise F5ModuleError("Failed to delete the monitor.")
        return True

    def read_current_from_device(self):
        resource = self.client.api.tm.ltm.monitor.snmp_dcas.snmp_dca.load(
            name=self.want.name,
            partition=self.want.partition
        )
        result = resource.attrs
        return Parameters(result)

    def exists(self):
        result = self.client.api.tm.ltm.monitor.snmp_dcas.snmp_dca.exists(
            name=self.want.name,
            partition=self.want.partition
        )
        return result

    def update_on_device(self):
        params = self.want.api_params()
        result = self.client.api.tm.ltm.monitor.snmp_dcas.snmp_dca.load(
            name=self.want.name,
            partition=self.want.partition
        )
        result.modify(**params)

    def create_on_device(self):
        params = self.want.api_params()
        self.client.api.tm.ltm.monitor.snmp_dcas.snmp_dca.create(
            name=self.want.name,
            partition=self.want.partition,
            **params
        )

    def remove_from_device(self):
        result = self.client.api.tm.ltm.monitor.snmp_dcas.snmp_dca.load(
            name=self.want.name,
            partition=self.want.partition
        )
        if result:
            result.delete()

class ArgumentSpec(object):
    def __init__(self):
        self.supports_check_mode = True
        self.argument_spec = dict(
            name=dict(required=True),
            description=dict(),
            parent=dict(),
            ip=dict(),
            interval=dict(type='int'),
            timeout=dict(type='int'),
            time_until_up=dict(type='int'),
            community=dict(),
            version=dict(),
            agent_type=dict(
                choices=['UCD', 'WIN2000', 'GENERIC']
            ),
            cpu_coefficient=dict(),
            cpu_threshold=dict(type='int'),
            memory_coefficient=dict(),
            memory_threshold=dict(type='int'),
            disk_coefficient=dict(),
            disk_threshold=dict(type='int')
        )
        self.f5_product_name = 'bigip'

def main():
    try:
        spec = ArgumentSpec()

        client = AnsibleF5Client(
            argument_spec=spec.argument_spec,
            supports_check_mode=spec.supports_check_mode,
            f5_product_name=spec.f5_product_name
        )

        if not HAS_F5SDK:
            raise F5ModuleError("The python f5-sdk module is required")

        mm = ModuleManager(client)
        results = mm.exec_module()
        client.module.exit_json(**results)
    except F5ModuleError as e:
        client.module.fail_json(msg=str(e))

if __name__ == '__main__':
    main()


text:
<?xml version="1.0" encoding="utf-8" ?>
<dwsync>
<file name="AppPickerActivity.java" server="web02.tripleclick.be" local="131370828600000000" remote="131370828600000000" />
<file name="BookmarkAdapter.java" server="web02.tripleclick.be" local="131370828600000000" remote="131370828600000000" />
<file name="BookmarkPickerActivity.java" server="web02.tripleclick.be" local="131370828600000000" remote="131370828600000000" />
<file name="LoadPackagesAsyncTask.java" server="web02.tripleclick.be" local="131370828600000000" remote="131370828600000000" />
<file name="ShareActivity.java" server="web02.tripleclick.be" local="131370828600000000" remote="131370828600000000" />
</dwsync>


text:
package com.thoughtworks.go.config;

import com.thoughtworks.go.domain.ConfigErrors;
import com.thoughtworks.go.domain.config.Admin;

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

@ConfigTag("security")
public class SecurityConfig implements Validatable {
    @ConfigSubtag(optional = true)
    private SecurityAuthConfigs securityAuthConfigs = new SecurityAuthConfigs();
    @ConfigSubtag(optional = true)
    private RolesConfig rolesConfig = new RolesConfig();
    @ConfigSubtag(optional = true)
    private AdminsConfig adminsConfig = new AdminsConfig();
    private ConfigErrors errors = new ConfigErrors();

    public SecurityConfig() {
    }

    public SecurityConfig(AdminsConfig admins) {
        this.adminsConfig = admins;
    }

    public boolean isSecurityEnabled() {
        return securityAuthConfigs != null && !securityAuthConfigs.isEmpty();
    }

    public AdminsConfig adminsConfig() {
        return adminsConfig;
    }

    public RolesConfig getRoles() {
        return rolesConfig;
    }

    public Role roleNamed(String roleName) {
        return rolesConfig.findByName(new CaseInsensitiveString(roleName));
    }

    public void addRole(Role role) {
        rolesConfig.add(role);
    }

    public boolean deleteRole(Role role) {
        return rolesConfig.remove(role);
    }

    public boolean deleteRole(String roleName) {
        return rolesConfig.remove(roleNamed(roleName));
    }

    public boolean isRoleExist(final CaseInsensitiveString role) {
        return rolesConfig.isRoleExist(role);
    }

    public boolean isAdmin(Admin admin) {
        return !isSecurityEnabled() || noAdminsConfigured() || adminsConfig.isAdmin(admin, rolesConfig.memberRoles(admin));
    }

    public boolean noAdminsConfigured() {
        return adminsConfig == null || adminsConfig.isEmpty();
    }

    public boolean isUserMemberOfRole(final CaseInsensitiveString userName, final CaseInsensitiveString roleName) {
        return rolesConfig.isUserMemberOfRole(userName, roleName);
    }

    public List<Role> memberRoleFor(final CaseInsensitiveString userName) {
        List<Role> roles = new ArrayList<>();
        for (Role role : rolesConfig) {
            if (isUserMemberOfRole(userName, role.getName())) {
                roles.add(role);
            }
        }
        return roles;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        SecurityConfig that = (SecurityConfig) o;

        if (securityAuthConfigs != null ? !securityAuthConfigs.equals(that.securityAuthConfigs) : that.securityAuthConfigs != null)
            return false;
        if (rolesConfig != null ? !rolesConfig.equals(that.rolesConfig) : that.rolesConfig != null) return false;
        if (adminsConfig != null ? !adminsConfig.equals(that.adminsConfig) : that.adminsConfig != null) return false;
        return errors != null ? errors.equals(that.errors) : that.errors == null;
    }

    @Override
    public int hashCode() {
        int result = securityAuthConfigs != null ? securityAuthConfigs.hashCode() : 0;
        result = 31 * result + (rolesConfig != null ? rolesConfig.hashCode() : 0);
        result = 31 * result + (adminsConfig != null ? adminsConfig.hashCode() : 0);
        result = 31 * result + (errors != null ? errors.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return String.format("SecurityConfig{securityAuthConfigs=%s, rolesConfig=%s, adminsConfig=%s}", securityAuthConfigs, rolesConfig, adminsConfig);
    }

    @Override
    public void validate(ValidationContext validationContext) {
    }

    @Override
    public ConfigErrors errors() {
        return errors;
    }

    @Override
    public void addError(String fieldName, String message) {
        errors.add(fieldName, message);
    }

    public SecurityAuthConfigs securityAuthConfigs() {
        return this.securityAuthConfigs;
    }

    public List<PluginRoleConfig> getPluginRoles(String pluginId) {
        List<PluginRoleConfig> result = new ArrayList<>();

        List<SecurityAuthConfig> authConfigs = securityAuthConfigs.findByPluginId(pluginId);
        List<PluginRoleConfig> pluginRoles = rolesConfig.getPluginRoleConfigs();

        for (SecurityAuthConfig authConfig : authConfigs) {
            for (PluginRoleConfig pluginRole : pluginRoles) {
                if (pluginRole.getAuthConfigId().equals(authConfig.getId())) {
                    result.add(pluginRole);
                }
            }
        }
        return result;
    }

    public PluginRoleConfig getPluginRole(CaseInsensitiveString roleName) {
        for (PluginRoleConfig pluginRoleConfig : rolesConfig.getPluginRoleConfigs()) {
            if (pluginRoleConfig.getName().equals(roleName)) {
                return pluginRoleConfig;
            }
        }
        return null;
    }

    public void setAdminsConfig(AdminsConfig admin) {
        this.adminsConfig = admin;
    }
}