Generate the identity source map and return the result.

@return the identity source map
@throws IOException
976520
public String generateSourceMap() throws IOException {
		final String sourceMethod = "generateSourceMap"; //$NON-NLS-1$
		final boolean isTraceLogging = log.isLoggable(Level.FINER);
		if (isTraceLogging) {
			log.entering(sourceClass, sourceMethod, new Object[]{name});
		}
		String result = null;
		lineLengths = getLineLengths();
		Compiler compiler = new Compiler();
		sgen = new SourceMapGeneratorV3();
		compiler.initOptions(compiler_options);
		currentLine = currentChar = 0;
		Node node = compiler.parse(JSSourceFile.fromCode(name, source));
		if (compiler.hasErrors()) {
			if (log.isLoggable(Level.WARNING)) {
				JSError[] errors = compiler.getErrors();
				for (JSError error : errors) {
					log.logp(Level.WARNING, sourceClass, sourceMethod, error.toString());
				}
			}
		}
		if (node != null) {
			processNode(node);
			StringWriter writer = new StringWriter();
			sgen.appendTo(writer, name);
			result = writer.toString();
		}
		sgen = null;
		lineLengths = null;
		if (isTraceLogging) {
			log.exiting(sourceClass, sourceMethod, result);
		}
		return result;
	}
248110
@JmxGetter(name = "getChunkIdToNumChunks", description = "Returns a string representation of the map of chunk id to number of chunks")
    public String getChunkIdToNumChunks() {
        StringBuilder builder = new StringBuilder();
        for(Entry<Object, Integer> entry: fileSet.getChunkIdToNumChunks().entrySet()) {
            builder.append(entry.getKey().toString() + " - " + entry.getValue().toString() + ", ");
        }
        return builder.toString();
    }
603742
public static final DefaultTupleMapper newBinaryDefaultTupleMapper( ) {
        return new DefaultTupleMapper(new TupleMapper<String>() {
            @Override
            public String map(Tuple input) {
                try {
                    return new String(input.getBinaryByField(FIELD_SOURCE), "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    throw new MappingException("Error while processing source as a byte[]", e);
                }
            }
        });
    }
1173584
public static Map<String, IDLProxyObject> create(Reader reader) throws IOException {
        return create(reader, false);
    }
130301
public static Map<String, IDLProxyObject> create(File file) throws IOException {
        return create(file, false);
    }
665501
private Identity getIdentityFromResultSet()
    {

        try
        {
            // 1. get an empty instance of the target class
            Constructor con = classDescriptor.getZeroArgumentConstructor();
            Object obj = ConstructorHelper.instantiate(con);

            // 2. fill only primary key values from Resultset
            Object colValue;
            FieldDescriptor fld;
            FieldDescriptor[] pkfields = classDescriptor.getPkFields();
            for (int i = 0; i < pkfields.length; i++)
            {
                fld = pkfields[i];
                colValue = fld.getJdbcType().getObjectFromColumn(resultSetAndStatment.m_rs, fld.getColumnName());
                fld.getPersistentField().set(obj, colValue);
            }
            // 3. return the representing identity object
            return broker.serviceIdentity().buildIdentity(classDescriptor, obj);
        }
        catch (SQLException e)
        {
            throw new PersistenceBrokerSQLException("Error reading object from column", e);
        }
        catch (Exception e)
        {
            throw new PersistenceBrokerException("Error reading Identity from result set", e);
        }
    }
642168
@Override
    public Map<String, DataSource> getDataSources() {
        HashMap<String, DataSource> map = new HashMap<>();
        for (Map.Entry<String, HikariDataSource> entry : sources.entrySet()) {
            if (entry.getValue() != null) {
                map.put(entry.getKey(), entry.getValue());
            }
        }
        return map;
    }
831231
public static Map<String, IAMSecurityCredential> getIAMSecurityCredentials() {
        Map<String, IAMSecurityCredential> credentialsInfoMap = new HashMap<String, IAMSecurityCredential>();

        List<String> credentials = getItems(EC2_METADATA_ROOT
                + "/iam/security-credentials");

        if (null != credentials) {
            for (String credential : credentials) {
                String json = getData(EC2_METADATA_ROOT
                        + "/iam/security-credentials/" + credential);
                try {
                    IAMSecurityCredential credentialInfo = mapper
                            .readValue(json, IAMSecurityCredential.class);
                    credentialsInfoMap.put(credential, credentialInfo);
                } catch (Exception e) {
                    log.warn("Unable to process the credential (" + credential
                            + "). " + e.getMessage(), e);
                }
            }
        }
        return credentialsInfoMap;
    }
428766
public <S, D> TypeMap<S, D> create(S source, Class<S> sourceType, Class<D> destinationType,
      String typeMapName, InheritingConfiguration configuration, MappingEngineImpl engine) {
    synchronized (lock) {
      TypeMapImpl<S, D> typeMap = new TypeMapImpl<S, D>(sourceType, destinationType, typeMapName,
          configuration, engine);
      if (configuration.isImplicitMappingEnabled()
          && Types.mightContainsProperties(typeMap.getSourceType())
          && Types.mightContainsProperties(typeMap.getDestinationType()))
        ImplicitMappingBuilder.build(source, typeMap, config.typeMapStore, config.converterStore);
      typeMaps.put(TypePair.of(sourceType, destinationType, typeMapName), typeMap);
      return typeMap;
    }
  }
300537
public Identity getIdentity()
    {
        if(identity == null)
        {
            identity = tx.getBroker().serviceIdentity().buildIdentity(obj);
        }
        return identity;
    }
1183886
private final String getIdAndName() {
        StringBuilder sb = new StringBuilder().append(id);
        if (identityName != null && identityName.length() > 0)
            sb.append(" (").append(identityName).append(')');
        return sb.toString();
    }
542315
public Query getPKQuery(Identity oid)
    {
        Object[] values = oid.getPrimaryKeyValues();
        ClassDescriptor cld = pb.getClassDescriptor(oid.getObjectsTopLevelClass());
        FieldDescriptor[] fields = cld.getPkFields();
        Criteria criteria = new Criteria();

        for (int i = 0; i < fields.length; i++)
        {
            FieldDescriptor fld = fields[i];
            criteria.addEqualTo(fld.getAttributeName(), values[i]);
        }
        return QueryFactory.newQuery(cld.getClassOfObject(), criteria);
    }
667855
private Identity build(BatchProto.Identity identityProto) {
        Identity identity = new Identity();
        identity.setChannelId(identityProto.getChannelId());
        identity.setPipelineId(identityProto.getPipelineId());
        identity.setProcessId(identityProto.getProcessId());
        return identity;
    }
849274
public Collection<String> getIdentifiers() {
    List<String> keys = new LinkedList<String>();
    keys.addAll(this.stateMap.keySet());
    return keys;
  }
1056099
public GetIdentityDkimAttributesResult withDkimAttributes(java.util.Map<String, IdentityDkimAttributes> dkimAttributes) {
        setDkimAttributes(dkimAttributes);
        return this;
    }
603205
public java.util.Map<String, IdentityDkimAttributes> getDkimAttributes() {
        if (dkimAttributes == null) {
            dkimAttributes = new com.amazonaws.internal.SdkInternalMap<String, IdentityDkimAttributes>();
        }
        return dkimAttributes;
    }
22728
public static Map<Identity, JsonNode> getDocumentIdMap(List<JsonNode> list, List<String> identityFields) {
        Map<Identity, JsonNode> map = new HashMap<>();
        if (list != null) {
            LOGGER.debug("Getting doc IDs for {} docs, fields={}", list.size(), identityFields);
            for (JsonNode node : list) {
                Identity id = new Identity(node, identityFields);
                LOGGER.debug("ID={}", id);
                map.put(id, node);
            }
        }
        return map;
    }