Send data with object mapper string.

@param sourceObject the source object
@param index        the index
@param type         the type
@return the string
773278
public String sendDataWithObjectMapper(Object sourceObject, String index,
            String type) {
        return sendDataWithObjectMapper(sourceObject, index, type, null)
                .getId();
    }
463149
@Override
	public <T> T get(int index, Class<T> type) {
		if (FETCHERS.containsKey(type))
			return getByType(index, type);
		else
			throw new IllegalArgumentException("has no value with " + type + " at index " + index);
	}
252098
public static void setJdbcType(String typeName, int typeIndex, JdbcType type)
    {
        setJdbcTypeByName(typeName, type);
        setJdbcTypeByTypesIndex(typeIndex, type);
    }
916539
public void sendBulkDataWithObjectMapperAsync(List<Object> objectBulkData,
            String index, String type) {
        executeBulkRequestAsync(buildBulkIndexRequestBuilder(objectBulkData
                .stream()
                .map(sourceObject -> jmESClient.prepareIndex(index, type)
                        .setSource(JMElasticsearchUtil
                                .buildSourceByJsonMapper(sourceObject)))
                .collect(toList())));
    }
820001
@SuppressWarnings("unchecked")
	public T get(int index) {
		T ret;
		if (JcRelation.class.equals(type)) {
			ret = (T) new JcRelation(null, this, OPERATOR.Collection.GET);
		} else if (JcNode.class.equals(type)) {
			ret = (T) new JcNode(null, this, OPERATOR.Collection.GET);
		} else {
			ret = (T) new JcValue(null, this, OPERATOR.Collection.GET);
		}
		ret.setHint(ValueAccess.hintKey_opValue, index);
		QueryRecorder.recordInvocationConditional(this, "get", ret, QueryRecorder.literal(index));
		return ret;
	}
983277
public <H extends EventHandler> H getHandler(GwtEvent.Type<H> type, int index) {
		return this.eventBus.superGetHandler(type, index);
	}
161845
public void sendWithBulkProcessor(List<? extends Map<String, ?>> bulkSource,
            String index, String type) {
        sendWithBulkProcessor(bulkSource.stream().map(
                source -> buildIndexRequest(index, type, null).source(source))
                .collect(toList()));
    }
127729
static String readMapping(String root, String index) throws IOException {
		if (root == null) {
			return readMapping(index);
		}
		String mappingFile = root + "/" + index + "/_doc" + Defaults.JsonFileExtension;
		return readFileFromClasspath(mappingFile);
	}
879235
public AiTextureMapMode getTextureMapModeW(AiTextureType type, int index) {
        checkTexRange(type, index);
        
        Property p = getProperty(PropertyKey.TEX_MAP_MODE_W.m_key);
        
        if (null == p || null == p.getData()) {
            return (AiTextureMapMode) m_defaults.get(
                    PropertyKey.TEX_MAP_MODE_W);
        }
        
        return AiTextureMapMode.fromRawValue(p.getData());
    }
259275
public Optional<MapperInstance> getKeySerializer( JType type ) {
        return Optional.fromNullable( keySerializers.get( type.getQualifiedSourceName() ) );
    }
376182
@Override
	public String convert(ObjectType sourceObject)
	{
		if(sourceObject == null)
			return null;
		
		String methodName = null;
		Object value =null;
		StringBuilder csv = new StringBuilder();
		Object[] args = {};
		Method m;

		
		for (Entry<String,Method> entry : this.methods.entrySet())
		{
			m = entry.getValue();
			methodName = m.getName();
			
			if(methodName.equals("getClass"))
				continue;
			
			try
			{
				value = m.invoke(sourceObject, args);
				
				if(csv.length() != 0)
					csv.append(SEPARATOR);
				
				csv.append(QUOTE).append(format(value)).append(QUOTE);
				
			}
			catch (IllegalAccessException|IllegalArgumentException|InvocationTargetException e)
			{
				throw new RuntimeException("Unable to get property for method:"+methodName+" error:"+e.getMessage(),e);
			}
		}
		
		csv.append(NEWLINE);
		
		return csv.toString();
		
	}
586144
public int reindex(String sourceIndex, String sourceType, String targetIndex) throws IOException {
        logger.debug("reindex [{}]/[{}] -> [{}]/[doc]", sourceIndex, sourceType, targetIndex);

        String reindexQuery = "{  \"source\": {\n" +
                "    \"index\": \"" + sourceIndex + "\",\n" +
                "    \"type\": \"" + sourceType + "\"\n" +
                "  },\n" +
                "  \"dest\": {\n" +
                "    \"index\": \"" + targetIndex + "\",\n" +
                "    \"type\": \"doc\"\n" +
                "  }\n" +
                "}\n";

        logger.trace("{}", reindexQuery);

        Request request = new Request("POST", "/_reindex");
        request.setJsonEntity(reindexQuery);

        Response restResponse = client.getLowLevelClient().performRequest(request);
        Map<String, Object> response = asMap(restResponse);
        logger.debug("reindex response: {}", response);

        return (int) response.get("total");
    }
360964
public ActionFuture<IndexResponse> sendDataAsync(
            Map<String, ?> source, String index, String type, String id) {
        return indexQueryAsync(buildIndexRequest(source, index, type, id));
    }
240196
public static final IndexReference indexRef(String indexName, IndexType type) {
        if (type == null) {
            return new IndexReference("`" + indexName + "`");
        }
        return new IndexReference("`" + indexName + "` USING " + type.toString());
    }
1328555
public Optional<MapperInstance> getKeyDeserializer( JType type ) {
        return Optional.fromNullable( keyDeserializers.get( type.getQualifiedSourceName() ) );
    }
1085886
private static void createTypeWithMappingInElasticsearch(RestHighLevelClient client, String index, String mapping)
            throws Exception {
        logger.trace("createTypeWithMappingInElasticsearch([{}])", index);

        assert client != null;
        assert index != null;

        if (mapping != null) {
            // Create mapping
            client.indices().putMapping(new PutMappingRequest(index).source(mapping, XContentType.JSON), RequestOptions.DEFAULT);
        } else {
            logger.trace("no content given for mapping. Ignoring mapping creation in index [{}].", index);
        }

        logger.trace("/createTypeWithMappingInElasticsearch([{}])", index);
    }
892793
public ActionFuture<IndexResponse> sendDataAsyncWithObjectMapper(
            Object sourceObject, String index, String type, String id) {
        return indexQueryAsync(buildIndexRequest(
                JMElasticsearchUtil.buildSourceByJsonMapper(sourceObject),
                index, type, id));
    }