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

import java.util.List;
import java.util.ArrayList;
import com.mozu.api.MozuClient;
import com.mozu.api.MozuClientFactory;
import com.mozu.api.MozuUrl;
import com.mozu.api.Headers;
import com.mozu.api.AsyncCallback;
import java.util.concurrent.CountDownLatch;
import com.mozu.api.security.AuthTicket;
import org.apache.commons.lang.StringUtils;

/**
 * Vocabulary values are predefined for an attribute.
 *
 */
public class AttributeVocabularyValueClient {

	/**
	 * Retrieves a list of vocabulary values defined for the attribute specified in the request.
	 *

	 * MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>> mozuClient=GetAttributeVocabularyValuesClient( attributeFQN);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValue attributeVocabularyValue = client.Result();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param dataViewMode DataViewMode
	 * @return Mozu.Api.MozuClient <List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 */
	public static MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>> getAttributeVocabularyValuesClient(String attributeFQN) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.getAttributeVocabularyValuesUrl(attributeFQN);
		String verb = "GET";
		Class<?> clz = new ArrayList<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>(){}.getClass();
		MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>> mozuClient = (MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		return mozuClient;

	}

	/**
	 * Retrieves a collection of localized content for vocabulary value attributes based on a `localeCode`.
	 *

	 * MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>> mozuClient=GetAttributeVocabularyValueLocalizedContentsClient( attributeFQN,  value);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValueLocalizedContent attributeVocabularyValueLocalizedContent = client.Result();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @return Mozu.Api.MozuClient <List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 */
	public static MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>> getAttributeVocabularyValueLocalizedContentsClient(String attributeFQN, String value) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.getAttributeVocabularyValueLocalizedContentsUrl(attributeFQN, value);
		String verb = "GET";
		Class<?> clz = new ArrayList<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>(){}.getClass();
		MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>> mozuClient = (MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		return mozuClient;

	}

	/**
	 * Retrieves the localized content for a vocabulary value attribute based on a `localeCode`.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient=GetAttributeVocabularyValueLocalizedContentClient( attributeFQN,  value,  localeCode);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValueLocalizedContent attributeVocabularyValueLocalizedContent = client.Result();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param localeCode Language used for the entity. Currently, only "en-US" is supported.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> getAttributeVocabularyValueLocalizedContentClient(String attributeFQN, String value, String localeCode) throws Exception
	{
		return getAttributeVocabularyValueLocalizedContentClient( attributeFQN,  value,  localeCode,  null);
	}

	/**
	 * Retrieves the localized content for a vocabulary value attribute based on a `localeCode`.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient=GetAttributeVocabularyValueLocalizedContentClient( attributeFQN,  value,  localeCode,  responseFields);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValueLocalizedContent attributeVocabularyValueLocalizedContent = client.Result();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param localeCode Language used for the entity. Currently, only "en-US" is supported.
	 * @param responseFields Use this field to include those fields which are not included by default.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> getAttributeVocabularyValueLocalizedContentClient(String attributeFQN, String value, String localeCode, String responseFields) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.getAttributeVocabularyValueLocalizedContentUrl(attributeFQN, localeCode, responseFields, value);
		String verb = "GET";
		Class<?> clz = com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent.class;
		MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient = (MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		return mozuClient;

	}

	/**
	 * Retrieves the details of a vocabulary value defined for an attribute by providing the attribute's fully qualified name and the value to retrieve.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient=GetAttributeVocabularyValueClient( attributeFQN,  value);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValue attributeVocabularyValue = client.Result();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValue>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> getAttributeVocabularyValueClient(String attributeFQN, String value) throws Exception
	{
		return getAttributeVocabularyValueClient( attributeFQN,  value,  null);
	}

	/**
	 * Retrieves the details of a vocabulary value defined for an attribute by providing the attribute's fully qualified name and the value to retrieve.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient=GetAttributeVocabularyValueClient( attributeFQN,  value,  responseFields);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValue attributeVocabularyValue = client.Result();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param responseFields Use this field to include those fields which are not included by default.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValue>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> getAttributeVocabularyValueClient(String attributeFQN, String value, String responseFields) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.getAttributeVocabularyValueUrl(attributeFQN, responseFields, value);
		String verb = "GET";
		Class<?> clz = com.mozu.api.contracts.productadmin.AttributeVocabularyValue.class;
		MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient = (MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		return mozuClient;

	}

	/**
	 * Creates and saves localized vocabulary value content for an attribute, based on the `localeCode`.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient=AddAttributeVocabularyValueLocalizedContentClient( localizedContent,  attributeFQN,  value);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValueLocalizedContent attributeVocabularyValueLocalizedContent = client.Result();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @param localizedContent The localized text for the string value of a product attribute.
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> addAttributeVocabularyValueLocalizedContentClient(com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent localizedContent, String attributeFQN, String value) throws Exception
	{
		return addAttributeVocabularyValueLocalizedContentClient( localizedContent,  attributeFQN,  value,  null);
	}

	/**
	 * Creates and saves localized vocabulary value content for an attribute, based on the `localeCode`.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient=AddAttributeVocabularyValueLocalizedContentClient( localizedContent,  attributeFQN,  value,  responseFields);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValueLocalizedContent attributeVocabularyValueLocalizedContent = client.Result();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param responseFields Use this field to include those fields which are not included by default.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @param localizedContent The localized text for the string value of a product attribute.
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> addAttributeVocabularyValueLocalizedContentClient(com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent localizedContent, String attributeFQN, String value, String responseFields) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.addAttributeVocabularyValueLocalizedContentUrl(attributeFQN, responseFields, value);
		String verb = "POST";
		Class<?> clz = com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent.class;
		MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient = (MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		mozuClient.setBody(localizedContent);
		return mozuClient;

	}

	/**
	 * Creates a vocabulary value for a defined product attribute.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient=AddAttributeVocabularyValueClient( attributeVocabularyValue,  attributeFQN);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValue attributeVocabularyValue = client.Result();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param dataViewMode DataViewMode
	 * @param attributeVocabularyValue Properties of a vocabulary value defined for an extensible attribute.
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValue>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> addAttributeVocabularyValueClient(com.mozu.api.contracts.productadmin.AttributeVocabularyValue attributeVocabularyValue, String attributeFQN) throws Exception
	{
		return addAttributeVocabularyValueClient( attributeVocabularyValue,  attributeFQN,  null);
	}

	/**
	 * Creates a vocabulary value for a defined product attribute.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient=AddAttributeVocabularyValueClient( attributeVocabularyValue,  attributeFQN,  responseFields);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValue attributeVocabularyValue = client.Result();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param responseFields Use this field to include those fields which are not included by default.
	 * @param dataViewMode DataViewMode
	 * @param attributeVocabularyValue Properties of a vocabulary value defined for an extensible attribute.
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValue>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> addAttributeVocabularyValueClient(com.mozu.api.contracts.productadmin.AttributeVocabularyValue attributeVocabularyValue, String attributeFQN, String responseFields) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.addAttributeVocabularyValueUrl(attributeFQN, responseFields);
		String verb = "POST";
		Class<?> clz = com.mozu.api.contracts.productadmin.AttributeVocabularyValue.class;
		MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient = (MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		mozuClient.setBody(attributeVocabularyValue);
		return mozuClient;

	}

	/**
	 * Update existing vocabulary values for an attribute.
	 *

	 * MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>> mozuClient=UpdateAttributeVocabularyValuesClient( vocabularyValues,  attributeFQN);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValue attributeVocabularyValue = client.Result();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param dataViewMode DataViewMode
	 * @param vocabularyValues Properties of a vocabulary value defined for an extensible attribute.
	 * @return Mozu.Api.MozuClient <List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 */
	public static MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>> updateAttributeVocabularyValuesClient(List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> vocabularyValues, String attributeFQN) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.updateAttributeVocabularyValuesUrl(attributeFQN);
		String verb = "PUT";
		Class<?> clz = new ArrayList<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>(){}.getClass();
		MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>> mozuClient = (MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		mozuClient.setBody(vocabularyValues);
		return mozuClient;

	}

	/**
	 * Updates a collection of localized vocabulary value content for existing attributes, based on the `localeCode`.
	 *

	 * MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>> mozuClient=UpdateAttributeVocabularyValueLocalizedContentsClient( localizedContent,  attributeFQN,  value);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValueLocalizedContent attributeVocabularyValueLocalizedContent = client.Result();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @param localizedContent The localized text for the string value of a product attribute.
	 * @return Mozu.Api.MozuClient <List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 */
	public static MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>> updateAttributeVocabularyValueLocalizedContentsClient(List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> localizedContent, String attributeFQN, String value) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.updateAttributeVocabularyValueLocalizedContentsUrl(attributeFQN, value);
		String verb = "PUT";
		Class<?> clz = new ArrayList<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>(){}.getClass();
		MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>> mozuClient = (MozuClient<List<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		mozuClient.setBody(localizedContent);
		return mozuClient;

	}

	/**
	 * Updates localized vocabulary value content for an existing attribute, based on the `localeCode`.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient=UpdateAttributeVocabularyValueLocalizedContentClient( localizedContent,  attributeFQN,  value,  localeCode);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValueLocalizedContent attributeVocabularyValueLocalizedContent = client.Result();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param localeCode The two character country code that sets the locale, such as US for United States. Sites, tenants, and catalogs use locale codes for localizing content, such as translated product text per supported country.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @param localizedContent The localized text for the string value of a product attribute.
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> updateAttributeVocabularyValueLocalizedContentClient(com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent localizedContent, String attributeFQN, String value, String localeCode) throws Exception
	{
		return updateAttributeVocabularyValueLocalizedContentClient( localizedContent,  attributeFQN,  value,  localeCode,  null);
	}

	/**
	 * Updates localized vocabulary value content for an existing attribute, based on the `localeCode`.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient=UpdateAttributeVocabularyValueLocalizedContentClient( localizedContent,  attributeFQN,  value,  localeCode,  responseFields);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValueLocalizedContent attributeVocabularyValueLocalizedContent = client.Result();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param localeCode The two character country code that sets the locale, such as US for United States. Sites, tenants, and catalogs use locale codes for localizing content, such as translated product text per supported country.
	 * @param responseFields Use this field to include those fields which are not included by default.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @param localizedContent The localized text for the string value of a product attribute.
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> updateAttributeVocabularyValueLocalizedContentClient(com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent localizedContent, String attributeFQN, String value, String localeCode, String responseFields) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.updateAttributeVocabularyValueLocalizedContentUrl(attributeFQN, localeCode, responseFields, value);
		String verb = "PUT";
		Class<?> clz = com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent.class;
		MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent> mozuClient = (MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValueLocalizedContent>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		mozuClient.setBody(localizedContent);
		return mozuClient;

	}

	/**
	 * Updates existing attribute vocabulary values.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient=UpdateAttributeVocabularyValueClient( attributeVocabularyValue,  attributeFQN,  value);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValue attributeVocabularyValue = client.Result();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @param attributeVocabularyValue Properties of a vocabulary value defined for an extensible attribute.
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValue>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> updateAttributeVocabularyValueClient(com.mozu.api.contracts.productadmin.AttributeVocabularyValue attributeVocabularyValue, String attributeFQN, String value) throws Exception
	{
		return updateAttributeVocabularyValueClient( attributeVocabularyValue,  attributeFQN,  value,  null);
	}

	/**
	 * Updates existing attribute vocabulary values.
	 *

	 * MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient=UpdateAttributeVocabularyValueClient( attributeVocabularyValue,  attributeFQN,  value,  responseFields);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 * AttributeVocabularyValue attributeVocabularyValue = client.Result();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param responseFields Use this field to include those fields which are not included by default.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @param attributeVocabularyValue Properties of a vocabulary value defined for an extensible attribute.
	 * @return Mozu.Api.MozuClient <com.mozu.api.contracts.productadmin.AttributeVocabularyValue>
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 * @see com.mozu.api.contracts.productadmin.AttributeVocabularyValue
	 */
	public static MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> updateAttributeVocabularyValueClient(com.mozu.api.contracts.productadmin.AttributeVocabularyValue attributeVocabularyValue, String attributeFQN, String value, String responseFields) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.updateAttributeVocabularyValueUrl(attributeFQN, responseFields, value);
		String verb = "PUT";
		Class<?> clz = com.mozu.api.contracts.productadmin.AttributeVocabularyValue.class;
		MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue> mozuClient = (MozuClient<com.mozu.api.contracts.productadmin.AttributeVocabularyValue>) MozuClientFactory.getInstance(clz);
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		mozuClient.setBody(attributeVocabularyValue);
		return mozuClient;

	}

	/**
	 * Deletes an attribute's vocabulary value.
	 *

	 * MozuClient mozuClient=DeleteAttributeVocabularyValueClient( attributeFQN,  value);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 *

	 * @param attributeFQN The fully qualified name of the attribute, which is a user defined attribute identifier.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @return Mozu.Api.MozuClient
	 */
	public static MozuClient deleteAttributeVocabularyValueClient(String attributeFQN, String value) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.deleteAttributeVocabularyValueUrl(attributeFQN, value);
		String verb = "DELETE";
				MozuClient mozuClient = (MozuClient) MozuClientFactory.getInstance();
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		return mozuClient;

	}

	/**
	 * Removes localized content for a vocabulary value attribute.
	 *

	 * MozuClient mozuClient=DeleteAttributeVocabularyValueLocalizedContentClient( attributeFQN,  value,  localeCode);
	 * client.setBaseAddress(url);
	 * client.executeRequest();
	 *

	 * @param attributeFQN Fully qualified name for an attribute.
	 * @param localeCode Language used for the entity. Currently, only "en-US" is supported.
	 * @param value The value string to create.
	 * @param dataViewMode DataViewMode
	 * @return Mozu.Api.MozuClient
	 */
	public static MozuClient deleteAttributeVocabularyValueLocalizedContentClient(String attributeFQN, String value, String localeCode) throws Exception
	{
		MozuUrl url = com.mozu.api.urls.commerce.catalog.admin.attributedefinition.attributes.AttributeVocabularyValueUrl.deleteAttributeVocabularyValueLocalizedContentUrl(attributeFQN, localeCode, value);
		String verb = "DELETE";
				MozuClient mozuClient = (MozuClient) MozuClientFactory.getInstance();
		mozuClient.setVerb(verb);
		mozuClient.setResourceUrl(url);
		return mozuClient;

	}

}


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package Type;

import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

/**
 * Singleton list of all available types
 * Also serves as a factory object to create Typings
 * @author Brittany
 */
public class TypeList {

    private static TypeList instance;
    private static ArrayList<String> all_types; //The actual list of types that we are generating from
    private final Random rand;
    private int single_type_weight; //chance of getting a single-type 'mon
    private int dual_type_weight; //chance of getting a dual-type 'mon

    //Private Constructor (necessary for singleton)
    private TypeList() {
        //TODO: read the list of types from an external config file or something
        //For now, here is a list of some placeholder types
        all_types = new ArrayList<>();
        all_types.add("Fire");
        all_types.add("Water");
        all_types.add("Grass");
        all_types.add("Normal");
        all_types.add("Bug");
        all_types.add("Flying");

        rand = new Random(); //For random number generation
        //Using Random() instead of ThreadLocalRandom for ease of testing later.

        single_type_weight = 1; //nonzero chance
        dual_type_weight = 1; //equal with single_type_weight (for now at least)
    }

    //If instance doesn't exist, create it. Either way, return it.
    public static TypeList getInstance() {
        if (instance == null) {
            instance = new TypeList();
        }
        return instance;
    }

    //Create a Typing object with random types
    public Typing genRandomTyping() {
        //Generate a primary type; equal chance of any type on the list
        int which_primary = rand.nextInt(all_types.size());

        //Does this typing have a secondary type?
        int single_or_dual = rand.nextInt(single_type_weight + dual_type_weight);
        if (single_or_dual < single_type_weight) { //single-type fakemon generated
            //Pass the generated primary type to the Typing constructor and return it
            return new Typing(all_types.get(which_primary));
        }
        else { //dual-type fakemon generated
            //Generate a second type; equal chance of any type on the list
            int which_secondary = rand.nextInt(all_types.size());
            //Pass the generated types to the Typing constructor and return it
            return new Typing(all_types.get(which_primary), all_types.get(which_secondary));
        }
    }//end function

}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

    <meta http-equiv="refresh" content="0;URL=type.U754.html">

Redirecting to type.U754.html...


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

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.12"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Nabu-asr: cluster.py File Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

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

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

Nabu-asr

nabu

distributed

Functions

cluster.py File Reference

contains functionality for creating a cluste
More...

Functions

def 	nabu.distributed.cluster.get_machines (machine_dir)

 	gets the machines that reported in the machine directory  More...

def 	nabu.distributed.cluster.read_cluster (filename)

 	read a cluster file  More...

def 	nabu.distributed.cluster.port_available (port)

 	check if port is available

Detailed Description

contains functionality for creating a cluste

Function Documentation

§ get_machines()

          def nabu.distributed.cluster.get_machines
          (

          machine_dir	)

gets the machines that reported in the machine directory

Parameters

machine_dir	the directory where the machines are reporting

Returns	a dictionary with keys ps and worker and lists containing the machines as elements

§ read_cluster()

          def nabu.distributed.cluster.read_cluster
          (

          filename	)

read a cluster file

Parameters

filename	the cluster file

Returns

a dictionary with ps and worker containing a list of machines

<address class="footer">
Generated by

 1.8.12
</address>


text:
/**
 * @version $Id: 8a6ffcf3b790f634f21b775fa708a80aadb4c15a $
 */

#ifndef TDME_NETWORK_NIOUDPSERVER
#define TDME_NETWORK_NIOUDPSERVER

#include <stdint.h>

#include <string>
#include <map>
#include <set>

#include <libtdme/threading/Thread.h>
#include <libtdme/threading/Barrier.h>
#include <libtdme/threading/ReadWriteLock.h>

#include <libtdme/network/shared/NIOServer.h>
#include <libtdme/network/shared/NIOServerWorkerThreadPool.h>

#include "NIOUDPServerIOThread.h"
#include "NIOUDPServerClient.h"
#include "NIOUDPServerGroup.h"

namespace TDMENetwork {

	using namespace TDMEThreading;

	class NIOUDPServerClient;

	/**
	 * Base class for NIO udp servers
	 * @author Andreas Drewke
	 */
	class NIOUDPServer : public NIOServer<NIOUDPServerClient, NIOUDPServerGroup>, public Thread {
		friend class NIOUDPServerClient;
		friend class NIOUDPServerIOThread;

		public:
			/**
			 * @brief Public constructor
			 * @param server name
			 * @param host where to bind the server socket
			 * @param port to listen on
			 * @param max ccu
			 */
			NIOUDPServer(const std::string& name, const std::string& host, const unsigned int port, const unsigned int maxCCU);

			/**
			 * @brief destructor
			 */
			virtual ~NIOUDPServer();

			/**
			 * main event loop
			 */
			virtual void run();

		protected:
			enum MessageType {MESSAGETYPE_CONNECT = 0, MESSAGETYPE_MESSAGE = 1, MESSAGETYPE_ACKNOWLEDGEMENT = 2};

			/**
			 * @brief method to implement for accepting clients
			 * @param client id
			 * @param ip
			 * @param port
			 * @return server client class
			 */
			virtual NIOUDPServerClient* accept(const uint32_t clientId, const std::string& ip, const unsigned int port);

			/**
			 * Identifies a client message
			 * @param frame
			 * @param message type (see NIOUDPServer::MessageType)
			 * @param connection id
			 * @param message id
			 * @param retries
			 * @throws NIONetworkServerException
			 * @return client or NULL
			 */
			virtual void identify(stringstream* frame, MessageType& messageType, uint32_t& connectionId, uint32_t& messageId, uint8_t& retries) throw (NIONetworkServerException);

			/**
			 * Validates a client message
			 * @param frame
			 * @throws NIONetworkServerException
			 */
			virtual void validate(stringstream* frame) throw (NIONetworkServerException);

			/**
			 * Writes a empty header to message
			 * @param frame
			 * @throws NIONetworkServerException
			 */
			virtual void writeHeader(stringstream* frame) throw (NIONetworkServerException);

			/**
			 * Writes a message header to message
			 * @param frame
			 * @param message type
			 * @param client id
			 * @param message id
			 * @param retries
			 * @throws NIONetworkServerException
			 */
			virtual void writeHeader(stringstream* frame, MessageType messageType, const uint32_t clientId, const uint32_t messageId, const uint8_t retries) throw (NIONetworkServerException);
		private:
			static const uint64_t CLIENT_CLEANUP_IDLETIME = 120000L;
			struct Client {
				uint32_t clientId;
				NIOUDPServerClient* client;
				uint64_t time;
			};
			typedef std::map<uint32_t, Client> ClientIdMap;
			typedef std::set<NIOUDPServerClient*> ClientSet;
			static const uint32_t MESSAGE_ID_NONE = 0;

			/**
			 * @brief maps a new client to a given client id
			 * @param client
			 * @throws NIONetworkServerException if id is already in use
			 */
			void addClient(NIOUDPServerClient* client) throw (NIONetworkServerException);

			/**
			 * @brief removes a client
			 * @param client
			 * @throws NIONetworkServerException if id is not in use
			 */
			void removeClient(NIOUDPServerClient* client) throw (NIONetworkServerException);

			/**
			 * @brief Look ups a client by client id
			 * @param client id
			 * @throws NIONetworkServerException if client does not exist
			 * @return client
			 */
			NIOUDPServerClient* lookupClient(const uint32_t clientId) throw (NIONetworkServerException);

			/**
			 * @brief Clean up clients that have been idle for some time or are flagged to be shut down
			 */
			void cleanUpClients();

			/**
			 * @brief pushes a message to be send, takes over ownership of frame
			 * @param client
			 * @param frame to be send
			 * @param safe, requires ack and retransmission
			 * @param message type
			 * @param message id (only for MESSAGETYPE_MESSAGE)
			 * @throws NIONetworkServerException
			 */
			void sendMessage(const NIOUDPServerClient* client, stringstream* frame, const bool safe, const MessageType messageType, const uint32_t messageId = MESSAGE_ID_NONE) throw (NIONetworkServerException);

			/**
			 * @brief Processes an acknowlegdement reception
			 * @param client
			 * @param message id
			 */
			void processAckReceived(NIOUDPServerClient* client, const uint32_t messageId) throw (NIONetworkServerException);

			/**
			 * @brief Allocates a client id for a new client
			 * @return client id
			 */
			const uint32_t allocateClientId();

			//
			ClientIdMap clientIdMap;
			ReadWriteLock clientIdMapReadWriteLock;

			unsigned int ioThreadCurrent;
			NIOUDPServerIOThread** ioThreads;
			NIOServerWorkerThreadPool *workerThreadPool;

			uint32_t clientCount;
			uint32_t messageCount;
	};

};

#endif


text:
const COMPONENTS_LIST = [
	{
		id: 0,
		category: 0,
		name: 'Grid',
		displayName: 'grid'
	},
	{
		id: 1,
		category: 0,
		name: 'FractalTree',
		displayName: 'Fractal Tree'
	},
	{
		id: 0,
		category: 0,
		name: 'Grid',
		displayName: 'grid'
	}
];

const CATEGORIES_LIST = [
	'CAT1'
]

const componentsInitialState = {
	activeCategoryIndex: -1,
	activeComponentIndex: -1,
	categories: CATEGORIES_LIST,
	filteredComponents: COMPONENTS_LIST
}

const componentsReducer = (state = componentsInitialState, action) => {
	switch (action.type) {
		case 'FILTER_BY_CATEGORY': {
			let category = CATEGORIES_LIST.indexof(action.payload.category);
			let filteredComponents = state.filteredComponents.filter(component => component.category === category);

			return {
				...state,
				filteredComponents,
				activeCategoryIndex: category,
				activeComponentIndex: filteredComponents.length || -1
			};
		}
		case 'FILTER_BY_ID': {
			let activeComponentIndex, activeCategoryIndex;

			for (var i = filteredComponents.length - 1; i >= 0; i--) {
				if( filteredComponents[i].id === action.payload.id ) {
					activeComponentIndex = i;
					activeCategoryIndex = filteredComponents[i].category;
				}
			}

			return {
				...state,
				activeCategoryIndex,
				activeComponentIndex
			}
		}
		case 'SEARCH': {
			let filteredComponents = COMPONENTS_LIST.filter(component => (
					component[i].id + '' === action.payload.searchStr ||
					component[i].name.indexOf(action.payload.searchStr) !== -1 ||
					component[i].displayName.indexOf(action.payload.searchStr) !== -1
				));

			return {
				...state,
				activeCategoryIndex: -1,
				activeComponentIndex: -1,
				filteredComponents
			}
		}
		case 'MOVE_UP': {
			let indexToGo = -1;

			if(state.filteredComponents.length === 0)
				indexToGo = -1;
			else if ( state.filteredComponents.length - 1 === state.activeComponentIndex )
				indexToGo = 0;
			else
				indexToGo = state.activeComponentIndex + 1;

			return {
				...state,
				activeComponentIndex
			}
		}
		case 'MOVE_DOWN': {
			let indexToGo = -1;

			if(state.filteredComponents.length === 0)
				indexToGo = -1;
			else if ( state.activeComponentIndex === 0 )
				indexToGo = state.filteredComponents.length - 1;
			else
				indexToGo = state.activeComponentIndex - 1;

			return {
				...state,
				activeComponentIndex
			}
		}
		default:
			return state
	}
}

export default componentsReducer;


text:
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="200dp" android:layout_height="100dp">

    <com.whlib.alib.widget.RoundRectImageView
        android:id="@+id/image_slider_image"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:src="@drawable/lenna"/>

    <TextView
        android:id="@+id/image_slider_txt"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="hello"/>
</FrameLayout>


text:
Data_sfml::Data_sfml()
{
	Fenetre.create(sf::VideoMode(800, 600, 32), "Creametry Wars", sf::Style::Close);
	Fenetre.setKeyRepeatEnabled(false);
	Fenetre.setVerticalSyncEnabled(false);
	Horloge.restart();
	CameraHud = Fenetre.getDefaultView();
}

// destructeurs
Data_sfml::~Data_sfml()
{}

// singleton
Data_sfml* Data_sfml::GetSingleton()
{
	static Data_sfml oData_sfml;
	return &oData_sfml;
}

// accesseurs
sf::RenderWindow* Data_sfml::GetFenetre()
{
	return &Fenetre;
}

sf::Event* Data_sfml::GetEvenements()
{
	return &Evenements;
}

sf::Clock* Data_sfml::GetHorloge()
{
	return &Horloge;
}

sf::View* Data_sfml::GetCameraHud()
{
	return &CameraHud;
}

sf::View* Data_sfml::GetCameraJeu()
{
	return &CameraJeu;
}

// mutateurs
void Data_sfml::SetCameraJeu()
{
	Joueur* m_pJoueur = Joueur::GetSingleton();

	CameraJeu.setCenter( sf::Vector2f( m_pJoueur->GetPosX(), m_pJoueur->GetPosY() ));
	CameraJeu.setSize(800, 600);
}


text:
package org.apache.flink.runtime.query;

import org.apache.flink.api.common.JobID;
import org.apache.flink.runtime.execution.SuppressRestartsException;
import org.apache.flink.runtime.executiongraph.ExecutionJobVertex;
import org.apache.flink.runtime.jobgraph.JobVertexID;
import org.apache.flink.runtime.state.KeyGroupRange;
import org.apache.flink.runtime.state.internal.InternalKvState;
import org.apache.flink.util.Preconditions;

import java.util.HashMap;
import java.util.Map;

/**
 * Simple registry, which maps {@link InternalKvState} registration notifications to
 * {@link KvStateLocation} instances.
 */
public class KvStateLocationRegistry {

	/** JobID this coordinator belongs to. */
	private final JobID jobId;

	/** Job vertices for determining parallelism per key. */
	private final Map<JobVertexID, ExecutionJobVertex> jobVertices;

	/**
	 * Location info keyed by registration name. The name needs to be unique
	 * per JobID, i.e. two operators cannot register KvState with the same
	 * name.
	 */
	private final Map<String, KvStateLocation> lookupTable = new HashMap<>();

	/**
	 * Creates the registry for the job.
	 *
	 * @param jobId       JobID this coordinator belongs to.
	 * @param jobVertices Job vertices map of all vertices of this job.
	 */
	public KvStateLocationRegistry(JobID jobId, Map<JobVertexID, ExecutionJobVertex> jobVertices) {
		this.jobId = Preconditions.checkNotNull(jobId, "JobID");
		this.jobVertices = Preconditions.checkNotNull(jobVertices, "Job vertices");
	}

	/**
	 * Returns the {@link KvStateLocation} for the registered KvState instance
	 * or null if no location information is available.
	 *
	 * @param registrationName Name under which the KvState instance is registered.
	 * @return Location information or null.
	 */
	public KvStateLocation getKvStateLocation(String registrationName) {
		return lookupTable.get(registrationName);
	}

	/**
	 * Notifies the registry about a registered KvState instance.
	 *
	 * @param jobVertexId JobVertexID the KvState instance belongs to
	 * @param keyGroupRange Key group range the KvState instance belongs to
	 * @param registrationName Name under which the KvState has been registered
	 * @param kvStateId ID of the registered KvState instance
	 * @param kvStateServerAddress Server address where to find the KvState instance
	 *
	 * @throws IllegalArgumentException If JobVertexID does not belong to job
	 * @throws IllegalArgumentException If state has been registered with same
	 * name by another operator.
	 * @throws IndexOutOfBoundsException If key group index is out of bounds.
	 */
	public void notifyKvStateRegistered(
			JobVertexID jobVertexId,
			KeyGroupRange keyGroupRange,
			String registrationName,
			KvStateID kvStateId,
			KvStateServerAddress kvStateServerAddress) {

		KvStateLocation location = lookupTable.get(registrationName);

		if (location == null) {
			// First registration for this operator, create the location info
			ExecutionJobVertex vertex = jobVertices.get(jobVertexId);

			if (vertex != null) {
				int parallelism = vertex.getMaxParallelism();
				location = new KvStateLocation(jobId, jobVertexId, parallelism, registrationName);
				lookupTable.put(registrationName, location);
			} else {
				throw new IllegalArgumentException("Unknown JobVertexID " + jobVertexId);
			}
		}

		// Duplicated name if vertex IDs don't match
		if (!location.getJobVertexId().equals(jobVertexId)) {
			IllegalStateException duplicate = new IllegalStateException(
					"Registration name clash. KvState with name '" + registrationName +
							"' has already been registered by another operator (" +
							location.getJobVertexId() + ").");

			ExecutionJobVertex vertex = jobVertices.get(jobVertexId);
			if (vertex != null) {
				vertex.fail(new SuppressRestartsException(duplicate));
			}

			throw duplicate;
		}
		location.registerKvState(keyGroupRange, kvStateId, kvStateServerAddress);
	}

	/**
	 * Notifies the registry about an unregistered KvState instance.
	 *
	 * @param jobVertexId JobVertexID the KvState instance belongs to
	 * @param keyGroupRange Key group index the KvState instance belongs to
	 * @param registrationName Name under which the KvState has been registered
	 * @throws IllegalArgumentException If another operator registered the state instance
	 * @throws IllegalArgumentException If the registration name is not known
	 */
	public void notifyKvStateUnregistered(
			JobVertexID jobVertexId,
			KeyGroupRange keyGroupRange,
			String registrationName) {

		KvStateLocation location = lookupTable.get(registrationName);

		if (location != null) {
			// Duplicate name if vertex IDs don't match
			if (!location.getJobVertexId().equals(jobVertexId)) {
				throw new IllegalArgumentException("Another operator (" +
						location.getJobVertexId() + ") registered the KvState " +
						"under '" + registrationName + "'.");
			}

			location.unregisterKvState(keyGroupRange);

			if (location.getNumRegisteredKeyGroups() == 0) {
				lookupTable.remove(registrationName);
			}
		} else {
			throw new IllegalArgumentException("Unknown registration name '" +
					registrationName + "'. " + "Probably registration/unregistration race.");
		}
	}

}


text:
<!DOCTYPE html>

	<meta charset="UTF-8" />
	<title>Draggable Scroll Tests</title>
	<link rel="stylesheet" href="../all.css" type="text/css">
	<link rel="stylesheet" href="../../../themes/base/jquery.ui.all.css" type="text/css">

Simple draggable

(Broken in IE)

Absolute

Absolute

Fixed

Fixed

Relative

Relative

Relative (Broken in IE)

Relative

Absolute

Absolute

Absolute

Absolute


text:
@import Foundation;
@import CoreLocation;

typedef void (^BCMBeaconNotificationNotifyBlock)(CLBeacon *beacon);
typedef BOOL (^BCMBeaconNotificationPredicateBlock)(CLBeacon *beacon);

@interface BCMBeaconNotification : NSObject

@property (nonatomic, copy) BCMBeaconNotificationNotifyBlock notify;
@property (nonatomic, copy) BCMBeaconNotificationPredicateBlock predicate;
@property (nonatomic, readwrite) BOOL repeat;
@property (nonatomic, readwrite) NSTimeInterval interval;
@property (nonatomic, readonly) BOOL notified;

+ (BCMBeaconNotification *)notificationWithNotify:(BCMBeaconNotificationNotifyBlock)notify usingPredicate:(BCMBeaconNotificationPredicateBlock)predicate;
- (void)notifyIfNeeded:(CLBeacon *)beacon;

@end


text:
import datetime
from decimal import Decimal
from flask.ext.jsontools import DynamicJSONEncoder

class CustomJSONEncoder(DynamicJSONEncoder):
    def default(self, obj):
        if hasattr(obj, 'to_json'):
            return obj.to_json()
        elif isinstance(obj, (datetime.datetime, datetime.date, datetime.time,)):
            return obj.isoformat()
        elif isinstance(obj, datetime.timedelta):
            return obj.total_seconds()
        elif isinstance(obj, Decimal):
            return str(obj)
        elif isinstance(obj, list) and not len(obj):
            return []
        else:
            return super().default(obj)


text:
CSSModal/*
 * CSS Modal Plugin for displaying an image gallery
 */
import CSSModal from '../js/CSSModal.js';

class CSSModalGallery extends CSSModal {
  constructor () {
    super();

    this._prev;
    this._next;
    this._detailView;
    this._activeElement;
    this._items = [];
    this._currentItem = 0;

    this.Helpers.on('cssmodal:show', document, this._initNavigation.bind(this));
    this.Helpers.on('cssmodal:hide', document, this._storeActiveItem.bind(this));

    return {
      showNext: this.showNext,
      showPrevious: this.showPrevious,
      setActiveItem: this.setActiveItem,
      setCaption: this.setCaption
    };
  }

  /**
   * Decreases the counter for the active item regarding the "endless"
   * setting.
   * @return {void}
   */
  _setPreviousItem () {
    if (this._currentItem === 0) {
      this._currentItem = (this._items.length - 1);
    } else {
      this._currentItem--;
    }
  }

  /**
   * Shows the content previous to the current item
   * @param  {Object} event The incoming touch/click event
   * @return {void}
   */
  showPrevious (event) {
    event.preventDefault();
    event.stopPropagation();

    this._setPreviousItem();

    this.setActiveItem(this._currentItem);
  }

  /**
   * Increases the counter for the active item regarding the "endless"
   * setting.
   * @return {void}
   */
  _setNextItem () {
    if (this._currentItem === (this._items.length - 1)) {
      this._currentItem = 0;
    } else {
      this._currentItem++;
    }
  }

  /**
   * Shows the content next to the current item
   * @param  {Object} event The incoming touch/click event
   * @return {void}
   */
  showNext (event) {
    event.preventDefault();
    event.stopPropagation();

    this._setNextItem();

    this.setActiveItem(this._currentItem);
  }

  /**
   * Returns the detail image element
   * @param  {Object} element The current CSS Modal instance
   * @return {Object} The detail image
   */
  _getDetailView (element) {
    let container = element.querySelectorAll('.css-modal_detail')[0];

    if (!container) {
      throw new Error('".css-modal_detail" not found!');
    }

    return container;
  }

  /**
   * Registers the listerns on the previous / next buttons to enable gallery
   * navigation
   * @return {void}
   */
  _initNavigation (event, eventData) {
    if (arguments.length === 2) {
      this._activeElement = eventData.detail.modal;
    } else {
      this._activeElement = event.detail.modal;
    }

    if (this._activeElement.querySelectorAll('.css-modal_detail').length === 0) {
      return;
    }

    // Bind events on the current modal element and set the currentItem to 0
    if (!this._activeElement._galleryEventsBound) {
      this._bindEvents(this._activeElement);
      this._activeElement._galleryEventsBound = true;
      this._activeElement._currentItem = 0;
    }

    // If we have an incoming index, override the current item
    if ('index' in this._activeElement) {
      this._activeElement._currentItem = this._activeElement.index;
    }

    this._detailView = this._getDetailView(this._activeElement);
    this._currentItem = this._activeElement._currentItem;
    this._items = this._readContent(this._activeElement);

    this.setActiveItem(this._currentItem);
  }

  /**
   * Reacts to specific keyboard commands to enable viewing a differnt item
   * in the gallery
   * @param  {Object} event The incoming keypress event
   * @return {void}
   */
  _onKeyPress (event) {
    if (event.keyCode === 39) {
      this.showNext(event);
    } else if (event.keyCode === 37) {
      this.showPrevious(event);
    }
  }

  /**
   * Wires the previous / next button to the function to navigation through
   * the gallery
   * @param  {Object} element The CSSModal to set up
   * @return {void}
   */
  _bindEvents (element) {
    var events = ['click', 'touch'];

    // Setup touch / click events
    this._prev = element.querySelectorAll('.modal--gallery-navigation-prev')[0];
    this._next = element.querySelectorAll('.modal--gallery-navigation-next')[0];

    for (let i = 0; i < events.length; i++) {
      this.Helpers.on(events[i], this._prev, this.showPrevious);
      this.Helpers.on(events[i], this._next, this.showNext);
    }

    // Setup keyboard events
    this.Helpers.on('keydown', document, this._onKeyPress);

    // Setup swipe events
    this.Helpers.on('touch:swipe-left', element, this.showPrevious);
    this.Helpers.on('touch:swipe-right', element, this.showNext);
  }

  /**
   * Gathers information about the gallery content and stores it.
   * @param  {Object} element The CSSModal to receive the content from
   * @return {void}
   */
  _readContent (element) {
    let contentList = element.querySelectorAll('.css-modal_content-list')[0];

    return contentList.getElementsByTagName('li');
  }

  /**
   * Set a caption for a given modal
   * @param {String} caption Caption to insert
   */
  setCaption (caption) {
    let captionElement = this._activeElement.querySelectorAll('.css_modal--gallery_caption')[0];

    if (!captionElement) {
      return;
    }

    captionElement.innerHTML = '';

    if (caption) {
      captionElement.innerHTML = '<p>' + caption + '</p>';
    }
  }

  /**
   * Shows the full content of the designated item
   * @param {Number} index The index of the item to show
   */
  setActiveItem (index) {
    if (!this._items[index]) {
      throw new Error('CSS-Modal: Invalid index "' + index + '"!');
    }

    var content = this._items[index].innerHTML;
    var img = new Image();
    var referenceImage;

    this._detailView.innerHTML = content;

    // Position for loading indicator and hide content
    this.Helpers.trigger('cssmodal:resize', this._activeElement);
    this.Helpers.removeClass(this._detailView, 'is-active');

    // Set a caption for the modal
    this.setCaption(this._items[index].getAttribute('data-caption'));

    // Load the original image, if we are in a gallery
    if (this._activeElement.getAttribute('class').indexOf('modal--gallery') !== -1) {
      referenceImage = this._detailView.getElementsByTagName('img')[0];

      if (referenceImage.parentNode.getAttribute('data-iframe') !== null) {
        img = document.createElement('iframe');
        img.src = referenceImage.getAttribute('data-src-fullsize');
        img.setAttribute('webkitallowfullscreen', true);
        img.setAttribute('mozallowfullscreen', true);
        img.setAttribute('allowfullscreen', true);

      } else {
        img.src = referenceImage.getAttribute('data-src-fullsize');
        img.alt = referenceImage.getAttribute('alt');
      }

      // Reposition and show
      this.Helpers.on('load', img, () => {
        this.Helpers.addClass(this._detailView, 'is-active');
        this.Helpers.trigger('cssmodal:resize', this._activeElement);
      });

      referenceImage.parentNode.insertBefore(img, referenceImage);
      referenceImage.parentNode.removeChild(referenceImage);

      this._detailView.style.width = 'auto';
      this._detailView.style.height = 'auto';
    }
  }

  /**
   * Store the index of the currently active item on the gallery instance
   * @param  {Number} item The index to store
   * @return {void}
   */
  _storeActiveItem () {
    this._activeElement._currentItem = this._currentItem;
  }
}

export default CSSModalGallery;


text:
namespace tao
{
   namespace TAOCPP_PEGTL_NAMESPACE
   {
      struct parse_error
         : public std::runtime_error
      {
         parse_error( const std::string& msg, std::vector< position >&& in_positions )
            : std::runtime_error( msg ),
              positions( std::move( in_positions ) )
         {
         }

         template< typename Input >
         parse_error( const std::string& msg, const Input& in )
            : parse_error( msg, in.position() )
         {
         }

         parse_error( const std::string& msg, const position& pos )
            : std::runtime_error( to_string( pos ) + ": " + msg ),
              positions( 1, pos )
         {
         }

         std::vector< position > positions;
      };

   }  // namespace TAOCPP_PEGTL_NAMESPACE

}  // namespace tao

#endif


text:
import Commerce = require('@chec/commerce.js');

const commerce = new Commerce('{your_public_key}');

const token = 'checkout_token_id';
const country = 'US';

// $ExpectType Promise<LocaleListCountriesResponse>
commerce.services.localeListCountries();

// $ExpectType Promise<LocaleListCountriesResponse>
commerce.services.localeListShippingCountries(token);

// $ExpectType Promise<LocaleListSubdivisionsResponse>
commerce.services.localeListShippingSubdivisions(token, country);

// $ExpectType Promise<LocaleListSubdivisionsResponse>
commerce.services.localeListSubdivisions(country);


text:
* [hiddentao/robe](https://github.com/hiddentao/robe) as Data ODM
* [Apollo Data](https://github.com/apollostack) as Data Transmission Layer
* [Passport.js](https://github.com/passport) as default Accounts system (Should be wrapped for easier usage)
   * [apollo-passport](https://www.npmjs.com/package/apollo-passport) works as Apollo with Passport.js
* [Vue.js](https://vuejs.org) as View Layer, with server-side rendering works out of box
* [Express.js](http://expressjs.com/) as server-side router
* [Webpack 2 with Rollup](https://www.npmjs.com/package/rollup-loader) as bundle builder for both client and server


text:
gfrd.github.com
======

The source code of http://egfrd.org/

LICENSE
------------

Copyright 2017 AMOLF.

Licensed under the MIT License.


text:
using System;
using Dibware.StoredProcedureFramework.Contracts;
using Dibware.StoredProcedureFramework.Helpers;
using Dibware.StoredProcedureFramework.Resources;
using Dibware.StoredProcedureFramework.StoredProcedureAttributes;

namespace Dibware.StoredProcedureFramework.Base
{
    public abstract class StoredProcedureBase : IStoredProcedure
    {
        #region Properties

        /// <summary>
        /// Gets the name of the procedure.
        /// </summary>
        /// <value>
        /// The name of the procedure.
        /// </value>
        public string ProcedureName
        {
            get { return _state.ProcedureName; }
        }

        /// <summary>
        /// Gets the name of the schema.
        /// </summary>
        /// <value>
        /// The name of the schema.
        /// </value>
        public string SchemaName
        {
            get { return _state.SchemaName; }
        }

        #endregion

        #region Methods

        /// <summary>
        /// Gets the name of the two part.
        /// </summary>
        /// <returns></returns>
        public string GetTwoPartName()
        {
            EnsureProcedureHasName();

            return String.Format(
                FormatStrings.TwoPartNameformat, SchemaName, ProcedureName);
        }

        /// <summary>
        /// Sets the procedure name.
        /// </summary>
        /// <param name="procedureName">Name of the procedure.</param>
        /// <returns>
        /// This instance
        /// </returns>
        /// <exception cref="System.ArgumentNullException">procedureName</exception>
        public void SetProcedureName(string procedureName)
        {
            // Validate argument
            if (procedureName == null) throw new ArgumentNullException("procedureName");
            if (procedureName == string.Empty) throw new ArgumentOutOfRangeException("procedureName");

            _state.ProcedureName = procedureName;
        }

        /// <summary>
        /// Sets the schema name.
        /// </summary>
        /// <param name="schemaName">The name of the schema.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException">schemaName</exception>
        public void SetSchemaName(string schemaName)
        {
            // Validate argument
            if (schemaName == null) throw new ArgumentNullException("schemaName");
            if (schemaName == string.Empty) throw new ArgumentOutOfRangeException("schemaName");

            _state.SchemaName = schemaName;
        }

        /// <summary>
        /// Determines if the specified type inherits from this object type.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        public static bool DoesTypeInheritsFromThis(Type type)
        {
            return typeof(StoredProcedureBase).IsAssignableFrom(type);
        }

        #endregion

        #region Methods : Private / protected

        private void EnsureProcedureHasName()
        {
            if (HasProcedureName()) return;

            string message = ExceptionMessages.StoredProcedureDoesNotHaveName;
            throw ExceptionHelper.CreateStoredProcedureConstructionException(message);
        }

        protected bool HasProcedureName()
        {
            return !String.IsNullOrEmpty(ProcedureName);
        }

        protected void TryInitializeFromAttributesInternal()
        {
            Type type = GetType();

            TrySetProcedureNameFromNameAttribute(type);
            TrySetSchemaNameFromSchemaAttribute(type);
        }

        private void TrySetProcedureNameFromNameAttribute(Type type)
        {
            NameAttribute attribute = Attribute.GetCustomAttribute(type, typeof(NameAttribute)) as NameAttribute;
            if (attribute != null)
            {
                SetProcedureName(attribute.Value);
            }
        }

        private void TrySetSchemaNameFromSchemaAttribute(Type type)
        {
            SchemaAttribute attribute = Attribute.GetCustomAttribute(type, typeof(SchemaAttribute)) as SchemaAttribute;
            if (attribute != null)
            {
                SetSchemaName(attribute.Value);
            }
        }

        #endregion

        #region State Structure

        protected struct StoredProcedureBaseState
        {
            public string ProcedureName;
            public string SchemaName;
        }

        #endregion

        #region Fields

        private StoredProcedureBaseState _state;

        #endregion
    }
}


text:
"""
Created on Wed Apr 13 16:02:16 2016

@author: Methinee
"""

import pandas as pd
import numpy as np
import pickle
import xlwt
from sklearn.ensemble import RandomForestClassifier
from sklearn.cross_validation import cross_val_score
book = xlwt.Workbook(encoding="utf-8")
sheet1 = book.add_sheet("Precission Without Merge")
sheet2 = book.add_sheet("Precission With Merge")

#----------------------Traning Data Without Merging-----------------------
df_file = pd.read_csv('../data/df_more20.csv',delimiter=",", skip_blank_lines = True,
                 error_bad_lines=False)

count_courseId = df_file["3COURSEID"].value_counts()
more20 = count_courseId

headers=list(df_file.columns.values)
subjects = {'courseId':[]}
countSub = 0
#Create dictionary of list subjects
for sub in df_file[headers[4]]:
    if sub not in subjects['courseId']:
        subjects['courseId'].append(sub)
        countSub = countSub+1
#Get subject that more 20 enrollment
count = 0
subjects["courseId"].sort()
precision_rf={}
df_precision_without = more20.copy()

for subject in subjects["courseId"]:
    print subject
    df_sub = df_file[df_file['3COURSEID'] == subject]
    df_sub = df_sub.iloc[np.random.permutation(len(df_sub))]
    count_enrollment = df_sub['3COURSEID'].value_counts()
    #print "Number of %s enrollment: %s"%(subject,count_enrollment)

    A = df_sub.as_matrix()
    X = A[:,6:]
    X = X.astype(np.int64, copy=False)
    y = A[:,5]
    y = y.astype(np.int64, copy=False)

    #Training data
    forest = RandomForestClassifier(n_estimators=10, max_depth=None,
                min_samples_split=1, random_state=None, max_features=None)
    clf = forest.fit(X, y)
    with_scores = cross_val_score(clf, X, y, cv=5)
    print with_scores
    print "Random Forest Cross Validation of %s: %s"%(subject,with_scores.mean())
    precision_rf[subject] = with_scores.mean()
    df_precision_without.loc[subject]=precision_rf[subject]
    print "-----------------------------------"

    sheet1.write(count, 0, subject)
    sheet1.write(count,1, with_scores.mean())
    book.save("RF_crossvalidation.xls")
    count = count+1

    #print all subjects
    #save trees to pickle file
    f = "tree/tree%s.pic"%subject
    with open(f, 'wb') as pickleFile:
        pickle.dump(clf, pickleFile, pickle.HIGHEST_PROTOCOL)

#df_precision.plot(kind='bar')

    #///////////////Find Importance Feature importances with forests of trees////////////////////
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification

importances = forest.feature_importances_
std = np.std([tree.feature_importances_ for tree in forest.estimators_],
                 axis=0)
indices = np.argsort(importances)[::-1]
list_grade = df_file.columns[6:]
# Print the feature ranking
print("Feature ranking:")

for f in range(X.shape[1]):
    print("%d. feature %s (%f)" % (f + 1, list_grade[indices[f]], importances[indices[f]]))

# Plot the feature importances of the forest
#plt.figure()
#plt.title("Feature importances")
#plt.bar(range(X.shape[1]), importances[indices],
#       color="r", yerr=std[indices], align="center")
#plt.xticks(range(X.shape[1]), indices)
#plt.xlim([-1, X.shape[1]])
#plt.show()

#----------------------Traning Data With Merging-----------------------
#df_file = pd.read_csv('../data/df_more20.csv',delimiter=",", skip_blank_lines = True,
#                 error_bad_lines=False)
df_file = pd.read_csv('../data/df_sub_more20_merge.csv',delimiter=",", skip_blank_lines = True,
                     error_bad_lines=False)

count_courseId = df_file["3COURSEID"].value_counts()
more20 = count_courseId

headers=list(df_file.columns.values)
subjects = {'courseId':[]}
countSub = 0
#Create dictionary of list subjects
for sub in df_file[headers[4]]:
    if sub not in subjects['courseId']:
        subjects['courseId'].append(sub)
        countSub = countSub+1
#Get subject that more 20 enrollment
count = 0
subjects["courseId"].sort()
precision_rf={}
df_precision_with = more20.copy()

for subject in subjects["courseId"]:
    print subject
    df_sub = df_file[df_file['3COURSEID'] == subject]
    df_sub = df_sub.iloc[np.random.permutation(len(df_sub))]
    count_enrollment = df_sub['3COURSEID'].value_counts()
    #print "Number of %s enrollment: %s"%(subject,count_enrollment)

    A = df_sub.as_matrix()
    X = A[:,6:]
    X = X.astype(np.int64, copy=False)
    y = A[:,5]
    y = y.astype(np.int64, copy=False)

    #Training data
    forest = RandomForestClassifier(n_estimators=10, max_depth=None,
                min_samples_split=1, random_state=None, max_features=None)
    clf = forest.fit(X, y)
    without_scores = cross_val_score(clf, X, y, cv=5)
    print without_scores
    print "Random Forest Cross Validation of %s: %s"%(subject,without_scores.mean())
    precision_rf[subject] = without_scores.mean()
    df_precision_with.loc[subject]=precision_rf[subject]
    print "-----------------------------------"

    sheet1.write(count,3, subject)
    sheet1.write(count,4, without_scores.mean())
    book.save("RF_crossvalidation.xls")
    count = count+1

    #print all subjects
    #save trees to pickle file
    f = "tree/tree%s.pic"%subject
    with open(f, 'wb') as pickleFile:
        pickle.dump(clf, pickleFile, pickle.HIGHEST_PROTOCOL)

#df_precision.plot(kind='bar')

    #///////////////Find Importance Feature importances with forests of trees////////////////////
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification

importances = forest.feature_importances_
std = np.std([tree.feature_importances_ for tree in forest.estimators_],
                 axis=0)
indices = np.argsort(importances)[::-1]
list_grade = df_file.columns[6:]
# Print the feature ranking
print("Feature ranking:")

for f in range(X.shape[1]):
    print("%d. feature %s (%f)" % (f + 1, list_grade[indices[f]], importances[indices[f]]))

# Plot the feature importances of the forest
#plt.figure()
#plt.title("Feature importances")
#plt.bar(range(X.shape[1]), importances[indices],
#       color="r", yerr=std[indices], align="center")
#plt.xticks(range(X.shape[1]), indices)
#plt.xlim([-1, X.shape[1]])
#plt.show()

#///////////////// Compare ///////////////////////////////////
DF = more20.copy()
compare = {}
for subject in subjects["courseId"]:
    DF1 = df_precision_with[subject]
    DF2 = df_precision_without[subject]
    compare[subject] = DF1-DF2
    print subject
    DF.loc[subject] = compare[subject]
DF.plot(kind='bar')


text:
package de.jpaw.xml.jaxb.scaledFp;

import de.jpaw.xml.jaxb.AbstractScaledDecimalAdapter;

public class ScaledDecimalAdapter4Round extends AbstractScaledDecimalAdapter {

    public ScaledDecimalAdapter4Round() {
        super(4, true);
    }
}


text:
import {loadScript, validateData} from '#3p/3p';

/**
 * @param {!Window} global
 * @param {!Object} data
 */
export function adagio(global, data) {
  validateData(data, ['sid', 'loc']);

  const $neodata = global;

  $neodata._adagio = {};
  $neodata._adagio.amp = data;

  loadScript($neodata, 'https://js-ssl.neodatagroup.com/adagio_amp.js');
}


text:
MongoDB\BSON\Regex unserialization requires "pattern" and "flags" string fields
--FILE--
<?php

require_once __DIR__ . '/../utils/tools.php';

echo throws(function() {
    unserialize('C:18:"MongoDB\BSON\Regex":33:{a:1:{s:7:"pattern";s:6:"regexp";}}');
}, 'MongoDB\Driver\Exception\InvalidArgumentException'), "\n";

echo throws(function() {
    unserialize('C:18:"MongoDB\BSON\Regex":26:{a:1:{s:5:"flags";s:1:"i";}}');
}, 'MongoDB\Driver\Exception\InvalidArgumentException'), "\n";

echo throws(function() {
    unserialize('C:18:"MongoDB\BSON\Regex":40:{a:2:{s:7:"pattern";i:0;s:5:"flags";i:0;}}');
}, 'MongoDB\Driver\Exception\InvalidArgumentException'), "\n";

?>
===DONE===
<?php exit(0); ?>
--EXPECT--
OK: Got MongoDB\Driver\Exception\InvalidArgumentException
MongoDB\BSON\Regex initialization requires "pattern" and "flags" string fields
OK: Got MongoDB\Driver\Exception\InvalidArgumentException
MongoDB\BSON\Regex initialization requires "pattern" and "flags" string fields
OK: Got MongoDB\Driver\Exception\InvalidArgumentException
MongoDB\BSON\Regex initialization requires "pattern" and "flags" string fields
===DONE===


text:
using System;
using Blade;

namespace Maui.Entities
{
    public partial class Currency
    {
        private Currency()
        {
        }

        public Currency( string name, string symbol )
        {
            Name = name;
            Symbol = symbol;
        }

        partial void OnNameChanging( string value )
        {
            ValidateName( value );
        }

        private static void ValidateName( string name )
        {
            if ( string.IsNullOrWhiteSpace( name ) )
            {
                throw new ArgumentException( "Name must not be null, empty or whitespace only" );
            }
        }

        partial void OnNameChanged()
        {
            var trimmedValue = Name.TrimOrNull();
            if ( trimmedValue != Name )
            {
                Name = trimmedValue;
            }
        }

        partial void OnSymbolChanging( string value )
        {
            ValidateSymbol( value );
        }

        private static void ValidateSymbol( string value )
        {
            if ( string.IsNullOrWhiteSpace( value ) )
            {
                throw new ArgumentException( "Symbol must not be null, empty or whitespace only" );
            }
        }

        partial void OnSymbolChanged()
        {
            var trimmedValue = Symbol.TrimOrNull();
            if ( trimmedValue != Symbol )
            {
                Symbol = trimmedValue;
            }
        }

        public override string ToString()
        {
            return Name;
        }
    }
}


text:
package org.omg.CosNaming.NamingContextPackage;

/**
* org/omg/CosNaming/NamingContextPackage/AlreadyBound.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from c:/re/workspace/8-2-build-windows-amd64-cygwin/jdk8u72/5732/corba/src/share/classes/org/omg/CosNaming/nameservice.idl
* Tuesday, December 22, 2015 7:17:37 PM PST
*/

public final class AlreadyBound extends org.omg.CORBA.UserException
{

  public AlreadyBound ()
  {
    super(AlreadyBoundHelper.id());
  } // ctor

  public AlreadyBound (String $reason)
  {
    super(AlreadyBoundHelper.id() + "  " + $reason);
  } // ctor

} // class AlreadyBound


text:
.. _datasets:

Datasets and Detectors
======================
A scan typically includes at least one detector.

Detectors are defined as devices that produce data. The data produced by
a detector is described by a table of Datasets. Each Dataset typically describes
a path within an HDF file.

Most scans include at least one detector block in the device layer and that
block must include a `DatasetTablePart`. This part adds a ``datasets``
attribute to the block which allows clients to determine the location and
shape of the data being produced by the detector.

Every part that produces data must return from configure() an `Infos <info_>`
of type `DatasetProducedInfo` for each dataset it will produce.

The DataSetTablePart collects these Infos and publishes them in the
``datasets`` Attribute.

Dataset tables should be NeXus compatible and as such would contain
a ``primary`` set, any number of
``secondary`` and ``monitor`` sets plus a ``position_set`` for each dimension
of the scan. It would also contain a ``position_value`` for each dimension
if axis read-backs are available. The definitions of these types
are provided by `DatasetType` as follows:

.. automodule:: malcolm.modules.scanning.util
    :members: DatasetType
    :noindex:


text:
function geodesicinverse(~, ~, ~)
%geodesicinverse  Solve inverse geodesic problem
%
%   [geodesic, aux] = geodesicinverse(latlong)
%   [geodesic, aux] = geodesicinverse(latlong, a, f)
%
%   latlong is an M x 4 matrix
%       latitude of point 1 = latlong(:,1) in degrees
%       longitude of point 1 = latlong(:,2) in degrees
%       latitude of point 2 = latlong(:,3) in degrees
%       longitude of point 2 = latlong(:,4) in degrees
%
%   geodesic is an M x 3 matrix
%       azimuth at point 1 = geodesic(:,1) in degrees
%       azimuth at point 2 = geodesic(:,2) in degrees
%       distance between points 1 and 2 = geodesic(:,3) in meters
%   aux is an M x 5 matrix
%       spherical arc length = aux(:,1) in degrees
%       reduced length = aux(:,2) in meters
%       geodesic scale 1 to 2 = aux(:,3)
%       geodesic scale 2 to 1 = aux(:,4)
%       area under geodesic = aux(:,5) in meters^2
%
%   a = major radius (meters)
%   f = flattening (0 means a sphere)
%   If a and f are omitted, the WGS84 values are used.
%
% The algorithm used in this function is given in
%
%     C. F. F. Karney, Algorithms for geodesics,
%     J. Geodesy 87, 43-55 (2013);
%     https://dx.doi.org/10.1007/s00190-012-0578-z
%     Addenda: http://geographiclib.sf.net/geod-addenda.html
%
% This is an interface to the GeographicLib C++ routine
%     Geodesic::Inverse
% See the documentation on this function for more information:
% http://geographiclib.sf.net/html/classGeographicLib_1_1Geodesic.html
%
% A native MATLAB implementation is available as GEODDISTANCE.
%
% See also GEODDISTANCE.

  error('Error: executing .m file instead of compiled routine');
end
% geodesicinverse.m
% Matlab .m file for solving inverse geodesic problem
%
% Copyright (c) Charles Karney (2010-2011) <charles@karney.com> and licensed
% under the MIT/X11 License.  For more information, see
% http://geographiclib.sourceforge.net/


text:
"""
Usage: python get_status.py [<serial>]

Gets the status of all APT controllers, or of the one specified
"""
import pyAPT

from runner import runner_serial

@runner_serial
def get_vel_params(serial):
  with pyAPT.MTS50(serial_number=serial) as con:
    min_vel, acc, max_vel = con.velocity_parameters()
    raw_min_vel, raw_acc, raw_max_vel = con.velocity_parameters(raw=True)
    print '\tController velocity parameters:'
    print '\t\tMin. Velocity: %.2fmm/s (%d)'%(min_vel, raw_min_vel)
    print '\t\tAcceleration: %.2fmm/s/s (%d)'%(acc, raw_acc)
    print '\t\tMax. Velocity: %.2fmm/s (%d)'%(max_vel, raw_max_vel)

if __name__ == '__main__':
  import sys
  sys.exit(get_vel_params())


text:
package org.mifos.dto.domain;

import java.util.Locale;

public class CenterCreation {

    private final Short officeId;
    private final Short loggedInUserId;
    private final Short loggedInUserLevelId;
    private final Locale locale;

    public CenterCreation(Short officeId, Short userId, Short userLevelId, Locale locale) {
        this.officeId = officeId;
        this.loggedInUserId = userId;
        this.loggedInUserLevelId = userLevelId;
        this.locale = locale;
    }

    public Short getOfficeId() {
        return this.officeId;
    }

    public Short getLoggedInUserId() {
        return this.loggedInUserId;
    }

    public Short getLoggedInUserLevelId() {
        return this.loggedInUserLevelId;
    }

    public Locale getLocale() {
        return this.locale;
    }
}


text:
package org.nlpcn.es4sql;

import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.plugin.nlpcn.QueryActionElasticExecutor;
import org.elasticsearch.plugin.nlpcn.executors.CSVResult;
import org.elasticsearch.plugin.nlpcn.executors.CSVResultsExtractor;
import org.elasticsearch.plugin.nlpcn.executors.CsvExtractorException;

import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.nlpcn.es4sql.domain.Condition;
import org.nlpcn.es4sql.domain.Select;
import org.nlpcn.es4sql.domain.Where;
import org.nlpcn.es4sql.exception.SqlParseException;
import org.nlpcn.es4sql.parse.ElasticSqlExprParser;
import org.nlpcn.es4sql.parse.ScriptFilter;
import org.nlpcn.es4sql.parse.SqlParser;
import org.nlpcn.es4sql.query.QueryAction;
import org.junit.Test;

import java.net.UnknownHostException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Created by allwefantasy on 8/25/16.
 */
public class SQLFunctionsTest {

    private static SqlParser parser;

    @BeforeClass
    public static void init() {
        parser = new SqlParser();
    }

    @Test
    public void functionFieldAliasAndGroupByAlias() throws Exception {
        String query = "SELECT " +
                "floor(substring(address,0,3)*20) as key," +
                "sum(age) cvalue FROM " + TestsConstants.TEST_INDEX + "/account where address is not null " +
                "group by key order by cvalue desc limit 10  ";
        SearchDao searchDao = MainTestSuite.getSearchDao() != null ? MainTestSuite.getSearchDao() : getSearchDao();
        System.out.println(searchDao.explain(query).explain().explain());

        CSVResult csvResult = getCsvResult(false, query);
        List<String> headers = csvResult.getHeaders();
        List<String> content = csvResult.getLines();
        Assert.assertEquals(2, headers.size());
        Assert.assertTrue(headers.contains("key"));
        Assert.assertTrue(headers.contains("cvalue"));
    }

    @Test
    public void functionAlias() throws Exception {
        //here is a bug,if only script fields are included,then all fields will return; fix later
        String query = "SELECT " +
                "substring(address,0,3) as key,address from " +
                TestsConstants.TEST_INDEX + "/account where address is not null " +
                "order by address desc limit 10  ";

        CSVResult csvResult = getCsvResult(false, query);
        List<String> headers = csvResult.getHeaders();
        List<String> content = csvResult.getLines();
        Assert.assertTrue(headers.contains("key"));
        Assert.assertTrue(content.contains("863 Wythe Place,863"));
    }

    @Test
    public void normalFieldAlias() throws Exception {

        //here is a bug,csv field with spa
        String query = "SELECT " +
                "address as key,age from " +
                TestsConstants.TEST_INDEX + "/account where address is not null " +
                "limit 10  ";

        CSVResult csvResult = getCsvResult(false, query);
        List<String> headers = csvResult.getHeaders();
        Assert.assertTrue(headers.contains("key"));
    }

    @Test
    public void groupByFieldAlias() throws Exception {

        //here is a bug,csv field with spa
        String query = "SELECT " +
                "age as key,sum(age) from " +
                TestsConstants.TEST_INDEX + "/account where address is not null " +
                " group by key limit 10  ";

        CSVResult csvResult = getCsvResult(false, query);
        List<String> headers = csvResult.getHeaders();
        List<String> contents = csvResult.getLines();
        Assert.assertTrue(headers.contains("key"));
        String[] splits = contents.get(0).split(",");
        Assert.assertTrue(Integer.parseInt(splits[0]) <= Double.parseDouble(splits[1]));
    }

    @Test
    public void concat_ws_field_and_string() throws Exception {

        //here is a bug,csv field with spa
        String query = "SELECT " +
                " concat_ws('-',age,'-'),address from " +
                TestsConstants.TEST_INDEX + "/account " +
                " limit 10  ";

        CSVResult csvResult = getCsvResult(false, query);
        List<String> headers = csvResult.getHeaders();
        List<String> contents = csvResult.getLines();
        String[] splits = contents.get(0).split(",");
        Assert.assertTrue(splits[0].endsWith("--") || splits[1].endsWith("--"));
    }

    @Test
    public void test() throws Exception {

        String query = "select sum(case \n" +
                "             when traffic=0 then 100 \n" +
                "             when traffic=1 then 1000 \n" +
                "             else 10000 \n" +
                "       end) as tf,date_format(5minute,'yyyyMMddHHmm') as nt  from traffic_statistics_v4_m200106 where business_line='2'   group by nt order by tf asc limit 10";

        SearchDao searchDao = MainTestSuite.getSearchDao() != null ? MainTestSuite.getSearchDao() : getSearchDao();
        System.out.println(searchDao.explain(query).explain().explain());
    }

// todo: change when split is back on language
//    @Test
//    public void whereConditionLeftFunctionRightVariableEqualTest() throws Exception {
//
//        String query = "SELECT " +
//                " * from " +
//                TestsConstants.TEST_INDEX + "/account " +
//                " where split(address,' ')[0]='806' limit 1000  ";
//
//        CSVResult csvResult = getCsvResult(false, query);
//        List<String> contents = csvResult.getLines();
//        Assert.assertTrue(contents.size() == 4);
//    }
//
//    @Test
//    public void whereConditionLeftFunctionRightVariableGreatTest() throws Exception {
//
//        String query = "SELECT " +
//                " * from " +
//                TestsConstants.TEST_INDEX + "/account " +
//                " where floor(split(address,' ')[0]+0) > 805 limit 1000  ";
//
//        SearchDao searchDao = MainTestSuite.getSearchDao() != null ? MainTestSuite.getSearchDao() : getSearchDao();
//        System.out.println(searchDao.explain(query).explain().explain());
//
//        CSVResult csvResult = getCsvResult(false, query);
//        List<String> contents = csvResult.getLines();
//        Assert.assertTrue(contents.size() == 223);
//    }

    @Test
    public void whereConditionLeftFunctionRightPropertyGreatTest() throws Exception {

        String query = "SELECT " +
                " * from " +
                TestsConstants.TEST_INDEX + "/account " +
                " where floor(split(address,' ')[0]+0) > b limit 1000  ";

        Select select = parser.parseSelect((SQLQueryExpr) queryToExpr(query));
        Where where = select.getWhere();
        Assert.assertTrue((where.getWheres().size() == 1));
        Assert.assertTrue(((Condition) (where.getWheres().get(0))).getValue() instanceof ScriptFilter);
        ScriptFilter scriptFilter = (ScriptFilter) (((Condition) (where.getWheres().get(0))).getValue());

        Assert.assertTrue(scriptFilter.getScript().contains("doc['address'].value.split(' ')[0]"));
        Pattern pattern = Pattern.compile("floor_\\d+ > doc\\['b'\\].value");
        Matcher matcher = pattern.matcher(scriptFilter.getScript());
        Assert.assertTrue(matcher.find());

    }

    private SQLExpr queryToExpr(String query) {
        return new ElasticSqlExprParser(query).expr();
    }

    @Test
    public void whereConditionLeftFunctionRightFunctionEqualTest() throws Exception {

        String query = "SELECT " +
                " * from " +
                TestsConstants.TEST_INDEX + "/account " +
                " where floor(split(address,' ')[0]+0) = floor(split(address,' ')[0]+0) limit 1000  ";

        Select select = parser.parseSelect((SQLQueryExpr) queryToExpr(query));
        Where where = select.getWhere();
        Assert.assertTrue((where.getWheres().size() == 1));
        Assert.assertTrue(((Condition) (where.getWheres().get(0))).getValue() instanceof ScriptFilter);
        ScriptFilter scriptFilter = (ScriptFilter) (((Condition) (where.getWheres().get(0))).getValue());
        Assert.assertTrue(scriptFilter.getScript().contains("doc['address'].value.split(' ')[0]"));
        Pattern pattern = Pattern.compile("floor_\\d+ == floor_\\d+");
        Matcher matcher = pattern.matcher(scriptFilter.getScript());
        Assert.assertTrue(matcher.find());
    }

    @Test
    public void whereConditionVariableRightVariableEqualTest() throws Exception {

        String query = "SELECT " +
                " * from " +
                TestsConstants.TEST_INDEX + "/account " +
                " where a = b limit 1000  ";

        SearchDao searchDao = MainTestSuite.getSearchDao() != null ? MainTestSuite.getSearchDao() : getSearchDao();
        System.out.println(searchDao.explain(query).explain().explain());

        Select select = parser.parseSelect((SQLQueryExpr) queryToExpr(query));
        Where where = select.getWhere();
        Assert.assertTrue((where.getWheres().size() == 1));
        Assert.assertTrue(((Condition) (where.getWheres().get(0))).getValue() instanceof ScriptFilter);
        ScriptFilter scriptFilter = (ScriptFilter) (((Condition) (where.getWheres().get(0))).getValue());
        Assert.assertTrue(scriptFilter.getScript().contains("doc['a'].value == doc['b'].value"));
    }

    @Test
    public void concat_ws_fields() throws Exception {

        //here is a bug,csv field with spa
        String query = "SELECT " +
                " concat_ws('-',age,address),address from " +
                TestsConstants.TEST_INDEX + "/account " +
                " limit 10  ";

        CSVResult csvResult = getCsvResult(false, query);
        List<String> headers = csvResult.getHeaders();
        List<String> contents = csvResult.getLines();
        Assert.assertTrue(headers.size() == 2);
        Assert.assertTrue(contents.get(0).contains("-"));
    }

    // todo: change when split is back on language
//    @Test
//    public void split_field() throws Exception {
//
//        //here is a bug,csv field with spa
//        String query = "SELECT " +
//                " split(address,' ')[0],age from " +
//                TestsConstants.TEST_INDEX + "/account where address is not null " +
//                " limit 10  ";
//        SearchDao searchDao = MainTestSuite.getSearchDao() != null ? MainTestSuite.getSearchDao() : getSearchDao();
//        System.out.println(searchDao.explain(query).explain().explain());
//
//        CSVResult csvResult = getCsvResult(false, query);
//        List<String> headers = csvResult.getHeaders();
//        List<String> contents = csvResult.getLines();
//        String[] splits = contents.get(0).split(",");
//        Assert.assertTrue(headers.size() == 2);
//        Assert.assertTrue(Integer.parseInt(splits[0]) > 0);
//    }

    private CSVResult getCsvResult(boolean flat, String query) throws SqlParseException, SQLFeatureNotSupportedException, Exception, CsvExtractorException {
        return getCsvResult(flat, query, false, false,false);
    }

    private CSVResult getCsvResult(boolean flat, String query, boolean includeScore, boolean includeType,boolean includeId) throws SqlParseException, SQLFeatureNotSupportedException, Exception, CsvExtractorException {
        SearchDao searchDao = MainTestSuite.getSearchDao() != null ? MainTestSuite.getSearchDao() : getSearchDao();
        QueryAction queryAction = searchDao.explain(query);
        Object execution = QueryActionElasticExecutor.executeAnyAction(searchDao.getClient(), queryAction);
        return new CSVResultsExtractor(includeScore, includeType, includeId).extractResults(execution, flat, ",");
    }

    private SearchDao getSearchDao() throws UnknownHostException {
        Settings settings = Settings.builder().put("client.transport.ignore_cluster_name", true).build();
        Client client = new PreBuiltTransportClient(settings).
                addTransportAddress(MainTestSuite.getTransportAddress());
        return new SearchDao(client);
    }
}


text:
bool efc::stmts::StatementList::type_check()
{
	return false;
}

bool efc::stmts::StatementList::requires_semicolon() const
{
	return false;
}


text:
package com.test.leetcode.medium;

import com.test.leetcode.common.TreeNode;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by ben on 2017/5/20.
 */
public class _508_MostFrequentSubtreeSum {
    private Map<Integer, Integer> result;

    public int[] findFrequentTreeSum(TreeNode root) {
        if (root == null) {
            return new int[0];
        }
        result = new HashMap<>();
        lastTravesal(root);

        int[] arr = new int[result.size()];
        int max = 1;
        int maxKey = 0;
        List<Integer> maxs = new ArrayList<>();
        int i = 0;
        for (Map.Entry<Integer, Integer> entry : result.entrySet()) {
            arr[i] = entry.getKey();
            if (entry.getValue() > max) {
                max = entry.getValue();
                maxKey = entry.getKey();
                maxs.clear();
                maxs.add(maxKey);
            } else if (entry.getValue() == max) {
                maxs.add(entry.getKey());
            }
            i++;
        }
        if (max > 1) {
            arr = new int[maxs.size()];
            for (int j = 0, length = maxs.size(); j < length; j++) {
                arr[j] = maxs.get(j);
            }
        }
        return arr;
    }

    private int lastTravesal(TreeNode node) {
        int a = 0, b = 0;
        if (node.left != null) {
            a = lastTravesal(node.left);
        }
        if (node.right != null) {
            b = lastTravesal(node.right);
        }
        node.val += a + b;
        if (result.keySet().contains(node.val)) {
            result.put(node.val, result.get(node.val) + 1);
        } else {
            result.put(node.val, 1);
        }
        return node.val;
    }
}


text:
import {
  commitMutation,
  graphql,
} from 'react-relay';
import {ConnectionHandler} from 'relay-runtime';

const mutation = graphql`
  mutation AddFoodMutation($input: FoodAddInput!) {
    addFood(input: $input) {
      __typename
      cursor
      node {
        id
        name
        type {
          id
          name
        }
      }
    }
  }
`;

let sharedUpdater = (store, newEdge) => {
  const conn = ConnectionHandler.getConnection(
    store.getRoot(),
    'FoodsList_foods'
  );
  ConnectionHandler.insertEdgeBefore(conn, newEdge);
};

let tempID = 0;

let commit = (environment, name, type_id) => {
  return commitMutation(
    environment,
    {
      mutation,
      variables: {
        input: {
          name,
          type_id
        },
      },
      updater: (store) => {
        const newEdge = store.getRootField('addFood');
        sharedUpdater(store, newEdge);
      },
      optimisticUpdater: (store) => {
        const id = 'client:newFood:' + tempID++;
        const node = store.create(id, 'Food');
        node.setValue(name, 'name');
        node.setValue(id, 'id');
        node.setLinkedRecord(store.get(type_id), 'type');
        const newEdge = store.create(
          'client:newEdge:' + tempID++,
          'FoodEdge',
        );
        newEdge.setLinkedRecord(node, 'node');
        sharedUpdater(store, newEdge);
      },
    }
  );
};

export default {commit};


text:
<?php

/* expression.twig */
class __TwigTemplate_6dfb0dac6371b90a05164776f5d3702c185fd1d270832992bdff84713e48e9b8 extends Twig_Template
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        $this->parent = false;

        $this->blocks = array(
        );
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        $__internal_8cdefe22ba9435a2a8e25419ba0d7340aa301ce4e4a395d72bf6f3de03ffede1 = $this->env->getExtension("Symfony\\Bridge\\Twig\\Extension\\ProfilerExtension");
        $__internal_8cdefe22ba9435a2a8e25419ba0d7340aa301ce4e4a395d72bf6f3de03ffede1->enter($__internal_8cdefe22ba9435a2a8e25419ba0d7340aa301ce4e4a395d72bf6f3de03ffede1_prof = new Twig_Profiler_Profile($this->getTemplateName(), "template", "expression.twig"));

        // line 1
        echo twig_escape_filter($this->env, (($this->getAttribute($this->getAttribute((isset($context["app"]) ? $context["app"] : $this->getContext($context, "app")), "user", array()), "id", array()) != $this->getAttribute((isset($context["user"]) ? $context["user"] : $this->getContext($context, "user")), "id", array())) && ($this->env->getExtension('Topxia\WebBundle\Twig\Extension\WebExtension')->getSetting("magic.enable_org", 0) == 1)), "html", null, true);

        $__internal_8cdefe22ba9435a2a8e25419ba0d7340aa301ce4e4a395d72bf6f3de03ffede1->leave($__internal_8cdefe22ba9435a2a8e25419ba0d7340aa301ce4e4a395d72bf6f3de03ffede1_prof);

    }

    public function getTemplateName()
    {
        return "expression.twig";
    }

    public function isTraitable()
    {
        return false;
    }

    public function getDebugInfo()
    {
        return array (  22 => 1,);
    }

    public function getSource()
    {
        return "{{ app.user.id != user.id and setting('magic.enable_org', 0) == 1 }}";
    }
}


text:
namespace paddle {
namespace inference {
namespace analysis {

void InferenceOpReplacePass::RunImpl(Argument* argument) {
  std::unordered_map<std::string, std::string> replaced_map{
      {"conditional_block", "conditional_block_infer"},
      {"merge_lod_tensor", "merge_lod_tensor_infer"},
  };

  auto& graph = argument->main_graph();
  auto nodes = graph.Nodes();

  for (auto& node : nodes) {
    if (!node->IsOp()) continue;
    auto* op_desc = node->Op();
    std::string op_type = op_desc->Type();
    if (!replaced_map.count(op_type)) continue;
    op_desc->SetType(replaced_map[op_type]);
    op_desc->Flush();
  }
}

std::string InferenceOpReplacePass::repr() const {
  return "inference-op-replace-pass";
}

}  // namespace analysis
}  // namespace inference
}  // namespace paddle


text:
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_activated="true" android:drawable="@drawable/ic_location_dark"/>
    <item android:drawable="@drawable/ic_location_dark"/>
</selector>