Combines the separate stereo encoder factories into a single factory.

@return a single stereo encoder factory
334365
private StereoEncoderFactory makeStereoEncoderFactory() {
        if (stereoEncoders.isEmpty()) {
            return StereoEncoderFactory.EMPTY;
        } else if (stereoEncoders.size() == 1) {
            return stereoEncoders.get(0);
        } else {
            StereoEncoderFactory factory = new ConjugatedEncoderFactory(stereoEncoders.get(0), stereoEncoders.get(1));
            for (int i = 2; i < stereoEncoders.size(); i++) {
                factory = new ConjugatedEncoderFactory(factory, stereoEncoders.get(i));
            }
            return factory;
        }
    }
850041
public <T0, T1, T2, T3, T4> SingleOutputStreamOperator<Tuple5<T0, T1, T2, T3, T4>> projectTuple5() {
		TypeInformation<?>[] fTypes = extractFieldTypes(fieldIndexes, dataStream.getType());
		TupleTypeInfo<Tuple5<T0, T1, T2, T3, T4>> tType = new TupleTypeInfo<Tuple5<T0, T1, T2, T3, T4>>(fTypes);

		return dataStream.transform("Projection", tType, new StreamProject<IN, Tuple5<T0, T1, T2, T3, T4>>(fieldIndexes, tType.createSerializer(dataStream.getExecutionConfig())));
	}
1068518
public ExtendedRegisterableItemsFactory build() {
        return new NoopExtendedRegisterableItemsFactory() {
            private RuntimeEngine _runtime;
            private List<EventListener> _listeners = new ArrayList<EventListener>();

            private synchronized List<EventListener> listeners(RuntimeEngine runtime) {
                if (_runtime != runtime) {
                    _runtime = runtime;
                    _listeners.clear();
                    KieRuntimeEventManager runtimeEventManager = _runtime.getKieSession();
                    for (ListenerBuilder builder : _listenerBuilders) {
                        EventListener listener = builder.build(runtimeEventManager);
                        if (listener != null && !builder.wasAutomaticRegistration()) {
                            _listeners.add(listener);
                        }
                    }
                }
                return new ArrayList<EventListener>(_listeners);
            }

            @Override
            public List<AgendaEventListener> getAgendaEventListeners(RuntimeEngine runtime) {
                List<AgendaEventListener> list = new ArrayList<AgendaEventListener>();
                for (EventListener listener : listeners(runtime)) {
                    if (listener instanceof AgendaEventListener) {
                        list.add((AgendaEventListener)listener);
                    }
                }
                return list;
            }

            @Override
            public List<ProcessEventListener> getProcessEventListeners(RuntimeEngine runtime) {
                List<ProcessEventListener> list = new ArrayList<ProcessEventListener>();
                if (_bpm) {
                    // always add our EventPublisherProcessEventListener for bpm component
                    list.add(new EventPublisherProcessEventListener(getServiceDomain().getEventPublisher()));
                }
                for (EventListener listener : listeners(runtime)) {
                    if (listener instanceof ProcessEventListener) {
                        list.add((ProcessEventListener)listener);
                    }
                }
                return list;
            }

            @Override
            public List<RuleRuntimeEventListener> getRuleRuntimeEventListeners(RuntimeEngine runtime) {
                List<RuleRuntimeEventListener> list = new ArrayList<RuleRuntimeEventListener>();
                for (EventListener listener : listeners(runtime)) {
                    if (listener instanceof RuleRuntimeEventListener) {
                        list.add((RuleRuntimeEventListener)listener);
                    }
                }
                return list;
            }

            @Override
            public Map<String, WorkItemHandler> getWorkItemHandlers(RuntimeEngine runtime) {
                Map<String, WorkItemHandler> map = new LinkedHashMap<String, WorkItemHandler>();
                // wih builder list will always be empty for rules component
                for (WorkItemHandlerBuilder builder : _workItemHandlerBuilders) {
                    ProcessRuntime processRuntime = runtime.getKieSession();
                    RuntimeManager runtimeManager = null;
                    if (runtime instanceof RuntimeEngineImpl) {
                        runtimeManager = ((RuntimeEngineImpl)runtime).getManager();
                    }
                    String name = builder.getWorkItemHandlerName();
                    WorkItemHandler handler = builder.build(processRuntime, runtimeManager);
                    map.put(name, handler);
                }
                return map;
            }

            @Override
            public List<KieBaseEventListener> getKieBaseEventListeners(RuntimeEngine runtime) {
                List<KieBaseEventListener> list = new ArrayList<KieBaseEventListener>();
                for (EventListener listener : listeners(runtime)) {
                    if (listener instanceof KieBaseEventListener) {
                        list.add((KieBaseEventListener)listener);
                    }
                }
                return list;
            }
        };
    }
1162835
public Audio[] getAudio() {
		List<Audio> list = getComponentModel().audio;
		return list == null ? null : list.toArray(new Audio[]{});
	}
1032033
protected synchronized static SAXParserFactory getSaxFactory()
    {
        if (sSaxFactory == null) {
            sSaxFactory = SAXParserFactory.newInstance();
            sSaxFactory.setNamespaceAware(true); 
        }
        return sSaxFactory;
    }
431501
public TupleGeneratorBuilder combiners( TupleCombiner... combiners)
    {
    for( TupleCombiner combiner : combiners)
      {
      tupleGenerator_.addCombiner( combiner);
      }
    return this;
    }
1299052
public MultipartConfigElement createMultipartConfig() {
		MultipartConfigFactory factory = new MultipartConfigFactory();
		PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
		map.from(this.fileSizeThreshold).to(factory::setFileSizeThreshold);
		map.from(this.location).whenHasText().to(factory::setLocation);
		map.from(this.maxRequestSize).to(factory::setMaxRequestSize);
		map.from(this.maxFileSize).to(factory::setMaxFileSize);
		return factory.createMultipartConfig();
	}
214096
private GrpcChannelFactory getChannelFactory() {
        if (this.channelFactory == null) {
            final GrpcChannelFactory factory = this.applicationContext.getBean(GrpcChannelFactory.class);
            this.channelFactory = factory;
            return factory;
        }
        return this.channelFactory;
    }
894714
private TransformerFactory getTransformerFactory()
        throws MojoFailureException, MojoExecutionException
    {
        if ( transformerFactory == null )
        {
            return TransformerFactory.newInstance();
        }

        try
        {
            return newTransformerFactory( transformerFactory, Thread.currentThread().getContextClassLoader() );
        }
        catch ( NoSuchMethodException exception )
        {
            throw new MojoFailureException( "JDK6 required when using transformerFactory parameter" );
        }
        catch ( IllegalAccessException exception )
        {
            throw new MojoExecutionException( "Cannot instantiate transformer factory", exception );
        }
        catch ( InvocationTargetException exception )
        {
            throw new MojoExecutionException( "Cannot instantiate transformer factory", exception );
        }
    }
129946
public FacesConfigFactoryType<FacesConfigType<T>> getOrCreateFactory()
   {
      List<Node> nodeList = childNode.get("factory");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigFactoryTypeImpl<FacesConfigType<T>>(this, "factory", childNode, nodeList.get(0));
      }
      return createFactory();
   }
46740
public <T0> SingleOutputStreamOperator<Tuple1<T0>> projectTuple1() {
		TypeInformation<?>[] fTypes = extractFieldTypes(fieldIndexes, dataStream.getType());
		TupleTypeInfo<Tuple1<T0>> tType = new TupleTypeInfo<Tuple1<T0>>(fTypes);

		return dataStream.transform("Projection", tType, new StreamProject<IN, Tuple1<T0>>(
				fieldIndexes, tType.createSerializer(dataStream.getExecutionConfig())));
	}
784807
public static <K, V> Factory<OffHeapBufferStorageEngine<K, V>> createFactory(final PointerSize width, final PageSource source, final int pageSize, final Portability<? super K> keyPortability, final Portability<? super V> valuePortability, final boolean thief, final boolean victim) {
    return () -> new OffHeapBufferStorageEngine<>(width, source, pageSize, keyPortability, valuePortability, thief, victim);
  }
486137
protected DialectFactory createDialectFactory() {
        DialectFactoryImpl factory = new DialectFactoryImpl();
        factory.injectServices(new ServiceRegistryImplementor() {

            @Override
            public <R extends Service> R getService(Class<R> serviceRole) {
                if (serviceRole == DialectResolver.class) {
                    return (R) new StandardDialectResolver();
                } else if (serviceRole == StrategySelector.class) {
                    return (R) new StrategySelectorImpl(new ClassLoaderServiceImpl(Thread.currentThread().getContextClassLoader()));
                }
                return null;
            }

            @Override
            public <R extends Service> ServiceBinding<R> locateServiceBinding(Class<R> serviceRole) {
                return null;
            }

            @Override
            public void destroy() {

            }

            @Override
            public void registerChild(ServiceRegistryImplementor child) {
            }

            @Override
            public void deRegisterChild(ServiceRegistryImplementor child) {
            }

            @Override
            public ServiceRegistry getParentServiceRegistry() {
                return null;
            }
        });
        return factory;
    }
492141
private Mixer createNewMixer()
	{
		Mixer mixer = currentContainer.createNewMixer();
		if (mixer!=null)
		{
			mixer.setVolume(initialVolume);
		}
		return mixer;
	}
554895
@Override
    @Input
    public String getCombinedInput() {
        return new CombinedInput(super.getCombinedInput())
                .add("dataBindingLayoutInfoOutFolder", null)
                .add("publicFile", getPublicFile())
                .add("blameLogFolder", getBlameLogFolder())
                .add(
                        "mergedNotCompiledResourcesOutputDirectory",
                        null)
                .toString();
    }
1016013
def mix2(servo1, servo2, mixtype=1, gain=0.5):
    ''''''
    (v1,v2) = mixer(servo1, servo2, mixtype=mixtype, gain=gain)
    return v2
54592
def create(input_width, input_height, input_channels=1):
    
    def instantiate(**_):
        return DoubleNatureCnn(input_width=input_width, input_height=input_height, input_channels=input_channels)

    return ModelFactory.generic(instantiate)