Get {@link JTransfo} instance with object finders, object replacers, convert interceptors and
type converters from Spring configuration.

@return {@link JTransfo} instance
553706
public JTransfo get() {
        ConfigurableJTransfo jTransfo = JTransfoFactory.get();
        if (null != typeConverters) {
            jTransfo.getTypeConverters().addAll(typeConverters);
            jTransfo.updateTypeConverters();
        }

        if (null != objectFinders) {
            jTransfo.getObjectFinders().addAll(objectFinders);
            jTransfo.updateObjectFinders();
        }

        if (null != convertInterceptors) {
            Collections.sort(convertInterceptors, new AnnotationAwareOrderComparator());
            jTransfo.getConvertInterceptors().addAll(convertInterceptors);
            jTransfo.updateConvertInterceptors();
        }

        if (null != objectReplacers) {
            List<ObjectReplacer> orderedInterceptors = new ArrayList<>();
            for (ObjectReplacer objectClassDeterminator : objectReplacers) {
                orderedInterceptors.add(objectClassDeterminator);
            }
            Collections.sort(orderedInterceptors, new AnnotationAwareOrderComparator());
            jTransfo.getObjectReplacers().addAll(orderedInterceptors);
            jTransfo.updateObjectReplacers();
        }
        return jTransfo;
    }
837366
public java.util.List<String> getDeclaredTransforms() {
        if (declaredTransforms == null) {
            declaredTransforms = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return declaredTransforms;
    }
466476
public static TopicWildcardTranslation getInstance() throws Exception
  {
    if (tcInt.isEntryEnabled()) Tr.entry(tcInt, "getInstance");
    
    if (twt == null)
    {  
      try
      {
        Class cls = Class.forName(UtConstants.TWT_FACTORY_CLASS);
        twt = (TopicWildcardTranslation) cls.newInstance();
      }       
      catch(InstantiationException ie)
      {
        // No FFDC code needed
        if (tcInt.isDebugEnabled())Tr.debug(tcInt, "Unable to instantiate TopicWildcardTranslation", ie);
        if (tcInt.isEntryEnabled())Tr.exit(tcInt, "getInstance");
          
        twt = null;     

        throw ie;
      } 
    }
     
    if (tcInt.isEntryEnabled()) Tr.exit(tcInt, "getInstance");
    return twt;
    
  }
161914
public static String getJavaClassFromSchemaInfo(String schemaInfo) {
        final String ONLY_JAVA_CLIENTS_SUPPORTED = "Only Java clients are supported currently, so the format of the schema-info should be: <schema-info>java=foo.Bar</schema-info> where foo.Bar is the fully qualified name of the message.";

        if(StringUtils.isEmpty(schemaInfo))
            throw new IllegalArgumentException("This serializer requires a non-empty schema-info.");

        String[] languagePairs = StringUtils.split(schemaInfo, ',');
        if(languagePairs.length > 1)
            throw new IllegalArgumentException(ONLY_JAVA_CLIENTS_SUPPORTED);

        String[] javaPair = StringUtils.split(languagePairs[0], '=');
        if(javaPair.length != 2 || !javaPair[0].trim().equals("java"))
            throw new IllegalArgumentException(ONLY_JAVA_CLIENTS_SUPPORTED);

        return javaPair[1].trim();
    }
1354715
public static ITransportPlugin GetTransportPlugin(ThriftConnectionType type, Map storm_conf, Configuration login_conf) {
        ITransportPlugin transportPlugin = null;
        try {
            String transport_plugin_klassName = type.getTransportPlugin(storm_conf);
            Class klass = Class.forName(transport_plugin_klassName);
            transportPlugin = (ITransportPlugin) klass.newInstance();
            transportPlugin.prepare(type, storm_conf, login_conf);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return transportPlugin;
    }
422712
@Override
    public String getBusName() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getBusName");
        String busName = jcaConnectionFactory.getBusName();
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getBusName", busName);
        return busName;
    }
1186900
private <A extends Annotation> AnnotationConverter<A> getConverter(Annotation annotation) {
		MappingOption mappingOption = annotation.annotationType().getAnnotation( MappingOption.class );
		if ( mappingOption == null ) {
			return null;
		}

		// wrong type would be a programming error of the annotation developer
		@SuppressWarnings("unchecked")
		Class<? extends AnnotationConverter<A>> converterClass = (Class<? extends AnnotationConverter<A>>) mappingOption.value();

		try {
			return converterClass.newInstance();
		}
		catch (Exception e) {
			throw log.cannotConvertAnnotation( converterClass, e );
		}
	}
588254
public MBeanInfo createMBeanInfo() {
        if (type != null) {
            return new MBeanInfo(type.getName(), description, getAttributeInfo(), getConstructorInfo(), getOperationInfo(), getNotificationInfo());
        } else {
            return new MBeanInfo(name, description, getAttributeInfo(), getConstructorInfo(), getOperationInfo(), getNotificationInfo());
        }
    }
656889
public com.google.privacy.dlp.v2.ReplaceWithInfoTypeConfigOrBuilder
      getReplaceWithInfoTypeConfigOrBuilder() {
    if (transformationCase_ == 7) {
      return (com.google.privacy.dlp.v2.ReplaceWithInfoTypeConfig) transformation_;
    }
    return com.google.privacy.dlp.v2.ReplaceWithInfoTypeConfig.getDefaultInstance();
  }
698445
private Collection<JaversType> bootJsonConverter() {
        JsonConverterBuilder jsonConverterBuilder = jsonConverterBuilder();

        addModule(new ChangeTypeAdaptersModule(getContainer()));
        addModule(new CommitTypeAdaptersModule(getContainer()));

        if (new RequiredMongoSupportPredicate().test(repository)) {
            jsonConverterBuilder.registerNativeGsonDeserializer(Long.class, new MongoLong64JsonDeserializer());
        }

        jsonConverterBuilder.registerJsonTypeAdapters(getComponents(JsonTypeAdapter.class));
        jsonConverterBuilder.registerNativeGsonDeserializer(Diff.class, new DiffTypeDeserializer());
        JsonConverter jsonConverter = jsonConverterBuilder.build();
        addComponent(jsonConverter);

        return Lists.transform(jsonConverterBuilder.getValueTypes(), c -> new ValueType(c));
    }
1359557
@Override
    public final void addTransformer(ClassTransformer transformerClass) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "addTransformer: PUID = " + ivArchivePuId + ", transformer = " + transformerClass); //d454146
        }

        if (transformerClass != null) {
            JPAComponent jpaComp = getJPAComponent();
            if (jpaComp != null && jpaComp.getCaptureEnhancedEntityClassBytecode()) {
                transformerClass = new CapturingClassTransformer(transformerClass, ivApplInfo.getApplName(), jpaComp.getServerLogDirectory());
            }
        }

        ivTransformers.add(transformerClass);

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "addTransformer : # registered transfromer = " + ivTransformers.size());
        }
    }
768241
public static BufferRecycler instance() {
        SoftReference<BufferRecycler> ref = recyclerRef.get();

        BufferRecycler bufferRecycler;
        if (ref == null) {
            bufferRecycler = null;
        } else {
            bufferRecycler = ref.get();
        }

        if (bufferRecycler == null) {
            bufferRecycler = new BufferRecycler();
            recyclerRef.set(new SoftReference<BufferRecycler>(bufferRecycler));
        }
        return bufferRecycler;
    }
549482
public PersistenceUnitTransactionType getTransactionType() {
          // Convert this TransactionType from the class defined in JAXB
          // (com.ibm.ws.jpa.pxml21.PersistenceUnitTransactionType) to JPA
          // (javax.persistence.spi.PersistenceUnitTransactionType).

          PersistenceUnitTransactionType rtnType = null;
          com.ibm.ws.jpa.pxml21.PersistenceUnitTransactionType jaxbType = null;

          jaxbType = ivPUnit.getTransactionType();
          if (jaxbType == com.ibm.ws.jpa.pxml21.PersistenceUnitTransactionType.JTA) {
               rtnType = PersistenceUnitTransactionType.JTA;
          } else if (jaxbType == com.ibm.ws.jpa.pxml21.PersistenceUnitTransactionType.RESOURCE_LOCAL) {
               rtnType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
          }
          return rtnType;
     }
1289412
@Override
    public TransactionManager newTransactionManager(Environment env) {
        return new JtaTransactionManager(
            env.get(EnvironmentName.TRANSACTION),
            env.get(EnvironmentName.TRANSACTION_SYNCHRONIZATION_REGISTRY),
            env.get(EnvironmentName.TRANSACTION_MANAGER ));
    }
282995
public HashMap<String, Object> getJsonToken() throws Exception {

		HashMap<String, Object> jRTObject = new HashMap<String, Object>();

		ArrayList<Object> jThreads = new ArrayList<Object>();
		for (CallStack.Thread thread : threads) {
			jThreads.add(thread.jsonToken());
		}

		jRTObject.put("threads", jThreads);
		jRTObject.put("threadCounter", threadCounter);

		return jRTObject;
	}
133520
private MBeanInfo buildMbeanInfo(JmxAttributeFieldInfo[] attributeFieldInfos,
			JmxAttributeMethodInfo[] attributeMethodInfos, JmxOperationInfo[] operationInfos, boolean ignoreErrors) {

		// NOTE: setup the maps that track previous class configuration
		Map<String, JmxAttributeFieldInfo> attributeFieldInfoMap = null;
		if (attributeFieldInfos != null) {
			attributeFieldInfoMap = new HashMap<String, JmxAttributeFieldInfo>();
			for (JmxAttributeFieldInfo info : attributeFieldInfos) {
				attributeFieldInfoMap.put(info.getFieldName(), info);
			}
		}
		Map<String, JmxAttributeMethodInfo> attributeMethodInfoMap = null;
		if (attributeMethodInfos != null) {
			attributeMethodInfoMap = new HashMap<String, JmxAttributeMethodInfo>();
			for (JmxAttributeMethodInfo info : attributeMethodInfos) {
				attributeMethodInfoMap.put(info.getMethodName(), info);
			}
		}
		Map<String, JmxOperationInfo> attributeOperationInfoMap = null;
		if (operationInfos != null) {
			attributeOperationInfoMap = new HashMap<String, JmxOperationInfo>();
			for (JmxOperationInfo info : operationInfos) {
				attributeOperationInfoMap.put(info.getMethodName(), info);
			}
		}

		Set<String> attributeNameSet = new HashSet<String>();
		List<MBeanAttributeInfo> attributes = new ArrayList<MBeanAttributeInfo>();
		// NOTE: methods override fields so subclasses can stop exposing of fields
		discoverAttributeMethods(attributeMethodInfoMap, attributeNameSet, attributes, ignoreErrors);
		discoverAttributeFields(attributeFieldInfoMap, attributeNameSet, attributes);
		List<MBeanOperationInfo> operations = discoverOperations(attributeOperationInfoMap);

		return new MBeanInfo(target.getClass().getName(), description,
				attributes.toArray(new MBeanAttributeInfo[attributes.size()]), null,
				operations.toArray(new MBeanOperationInfo[operations.size()]), null);
	}
378738
public Transient<EmbeddableAttributes<T>> getOrCreateTransient()
   {
      List<Node> nodeList = childNode.get("transient");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new TransientImpl<EmbeddableAttributes<T>>(this, "transient", childNode, nodeList.get(0));
      }
      return createTransient();
   }