Apply connection definition to connection manager configuration
@param cmc The connection manager configuration
@param cd The connection definition definition
340606
private void applyConnectionManagerConfiguration(ConnectionManagerConfiguration cmc,
      org.ironjacamar.common.api.metadata.resourceadapter.ConnectionDefinition cd)
   {
      if (cd.getJndiName() != null)
         cmc.setJndiName(cd.getJndiName());

      if (cd.isSharable() != null)
         cmc.setSharable(cd.isSharable());

      if (cd.isEnlistment() != null)
         cmc.setEnlistment(cd.isEnlistment());

      if (cd.isConnectable() != null)
         cmc.setConnectable(cd.isConnectable());

      if (cd.isTracking() != null)
         cmc.setTracking(cd.isTracking());
   }
1238023
Set<ConnectionManager> getConnectionManagers()
   {
      if (cmToCl == null)
         return Collections.unmodifiableSet(Collections.emptySet());

      return Collections.unmodifiableSet(cmToCl.keySet());
   }
746310
public function bind(Client $client, ConnectionManager $cm)
    {
        $this->client = $client;
        $this->connectionManager = $cm;
        $this->bindMethods([
            'irc.sent' => 'onIrcSent',
            'irc.received' => 'onIrcReceived',
            'irc.tick' => 'onIrcTick',
            'connect.end' => 'onConnectEnd',
            'connect.error' => 'onConnectError',
            'connect.before.each' => 'onConnectBeforeEach',
            'connect.after.each'  => 'onConnectAfterEach'
        ]);
    }
1371547
public void link(Object source, CollectionDescriptor cds, List referencesToLink)
    {
        for(int i = 0; i < referencesToLink.size(); i++)
        {
            link(source, cds, referencesToLink.get(i));
        }
    }
1202768
public void setDirectConnectGatewayAssociationProposals(
            java.util.Collection<DirectConnectGatewayAssociationProposal> directConnectGatewayAssociationProposals) {
        if (directConnectGatewayAssociationProposals == null) {
            this.directConnectGatewayAssociationProposals = null;
            return;
        }

        this.directConnectGatewayAssociationProposals = new com.amazonaws.internal.SdkInternalList<DirectConnectGatewayAssociationProposal>(
                directConnectGatewayAssociationProposals);
    }
921480
@Override
	public void addConnectorCustomizers(
			TomcatConnectorCustomizer... tomcatConnectorCustomizers) {
		Assert.notNull(tomcatConnectorCustomizers,
				"TomcatConnectorCustomizers must not be null");
		this.tomcatConnectorCustomizers.addAll(Arrays.asList(tomcatConnectorCustomizers));
	}
628534
public void setJdbc(java.util.Collection<CodeGenNodeArg> jdbc) {
        if (jdbc == null) {
            this.jdbc = null;
            return;
        }

        this.jdbc = new java.util.ArrayList<CodeGenNodeArg>(jdbc);
    }
1359625
public static void runExample(AdManagerServices adManagerServices, AdManagerSession session)
      throws RemoteException {
    CdnConfigurationServiceInterface cdnConfigurationService =
        adManagerServices.get(session, CdnConfigurationServiceInterface.class);

    // Create a statement to select CDN configurations.
    int pageSize = StatementBuilder.SUGGESTED_PAGE_LIMIT;
    StatementBuilder statementBuilder = new StatementBuilder().orderBy("id ASC").limit(pageSize);

    // Retrieve a small amount of CDN configurations at a time, paging through until all
    // CDN configurations have been retrieved.
    int totalResultSetSize = 0;
    do {
      CdnConfigurationPage page =
          cdnConfigurationService.getCdnConfigurationsByStatement(statementBuilder.toStatement());

      // Print out some information for each CDN configuration.
      if (page.getResults() != null) {
        totalResultSetSize = page.getTotalResultSetSize();
        int i = page.getStartIndex();
        for (CdnConfiguration cdnConfiguration : page.getResults()) {
          System.out.printf(
              "%d) CDN configuration with ID %d and name '%s' was found.%n",
              i++, cdnConfiguration.getId(), cdnConfiguration.getName());
        }
      }

      statementBuilder.increaseOffsetBy(pageSize);
    } while (statementBuilder.getOffset() < totalResultSetSize);

    System.out.printf("Number of results found: %d%n", totalResultSetSize);
  }
335202
protected void addPartialInfo(ClassDoc cd, Content contentTree) {
        addPreQualifiedStrongClassLink(LinkInfoImpl.Kind.TREE, cd, contentTree);
    }
446950
public void addCc(String cc) {
        if (this.cc.length() > 0) {
            this.cc.append(",");
        }
        this.cc.append(cc);
    }
718402
@Override
   public <C extends ConnectionFactoryConfigurationBuilder<?>> C connectionFactory(Class<C> klass) {
      if (connectionFactory != null) {
         throw new IllegalStateException("A ConnectionFactory has already been configured for this store");
      }
      try {
         Constructor<C> constructor = klass.getDeclaredConstructor(AbstractJdbcStoreConfigurationBuilder.class);
         C builder = constructor.newInstance(this);
         this.connectionFactory = (ConnectionFactoryConfigurationBuilder<ConnectionFactoryConfiguration>) builder;
         return builder;
      } catch (Exception e) {
         throw new CacheConfigurationException("Could not instantiate loader configuration builder '" + klass.getName() + "'", e);
      }
   }
1314400
private void setupConnection(final Connection connection) throws ConnectionSetupException
   {
      try {
         if (networkTimeout == UNINITIALIZED) {
            networkTimeout = getAndSetNetworkTimeout(connection, validationTimeout);
         }
         else {
            setNetworkTimeout(connection, validationTimeout);
         }

         if (connection.isReadOnly() != isReadOnly) {
            connection.setReadOnly(isReadOnly);
         }

         if (connection.getAutoCommit() != isAutoCommit) {
            connection.setAutoCommit(isAutoCommit);
         }

         checkDriverSupport(connection);

         if (transactionIsolation != defaultTransactionIsolation) {
            connection.setTransactionIsolation(transactionIsolation);
         }

         if (catalog != null) {
            connection.setCatalog(catalog);
         }

         if (schema != null) {
            connection.setSchema(schema);
         }

         executeSql(connection, config.getConnectionInitSql(), true);

         setNetworkTimeout(connection, networkTimeout);
      }
      catch (SQLException e) {
         throw new ConnectionSetupException(e);
      }
   }
384049
private static List<Validate> createManagedConnectionFactory(Connector cmd,
         List<Failure> failures, ResourceBundle rb, ClassLoader cl)
   {
      List<Validate> result = new ArrayList<Validate>();

      if (cmd.getVersion() != Version.V_10 &&
          cmd.getResourceadapter() != null &&
          cmd.getResourceadapter().getOutboundResourceadapter() != null &&
          cmd.getResourceadapter().getOutboundResourceadapter().getConnectionDefinitions() != null)
      {
         List<ConnectionDefinition> cdMetas = cmd.getResourceadapter()
               .getOutboundResourceadapter().getConnectionDefinitions();
         if (!cdMetas.isEmpty())
         {
            for (ConnectionDefinition cdMeta : cdMetas)
            {
               if (cdMeta.getManagedConnectionFactoryClass() != null)
               {
                  try
                  {
                     Class<?> clazz = Class.forName(cdMeta.getManagedConnectionFactoryClass().getValue(), true, cl);
                     List<ConfigProperty> configProperties = cdMeta.getConfigProperties();

                     ValidateClass vc = new ValidateClass(Key.MANAGED_CONNECTION_FACTORY, clazz, configProperties);
                     result.add(vc);
                  }
                  catch (ClassNotFoundException | NoClassDefFoundError e)
                  {
                     Failure failure = new Failure(Severity.ERROR,
                                                   rb.getString("uncategorized"),
                                                   rb.getString("mcf.cnfe"),
                                                   e.getMessage());
                     failures.add(failure);
                  }
               }

            }
         }
      }

      return result;
   }
951324
public void setWorkConnection(CmsSetupDb db) {

        db.setConnection(
            m_setupBean.getDbDriver(),
            m_setupBean.getDbWorkConStr(),
            m_setupBean.getDbConStrParams(),
            m_setupBean.getDbWorkUser(),
            m_setupBean.getDbWorkPwd());
    }
126266
private boolean shouldEnlist(ConnectionListener cl)
   {
      if (cmConfiguration.isEnlistment() && cl.getManagedConnection() instanceof LazyEnlistableManagedConnection)
         return false;

      return true;
   }
1020365
@Override
    public void associateConnection( Object connection ) throws ResourceException {
        JcrSessionHandle handle = (JcrSessionHandle)connection;
        if (handle.getManagedConnection() != this) {
            handle.getManagedConnection().removeHandle(handle);
            handle.setManagedConnection(this);
            addHandle(handle);
        }
    }
451728
@SuppressWarnings("deprecation")
  public static DefaultHttpClient getClientThatAllowAnyHTTPS(ThreadSafeClientConnManager cm) {

    final TrustManager easyTrustManager = new X509TrustManager() {


      public void checkClientTrusted(X509Certificate[] xcs, String string)
          throws CertificateException {}

      public void checkServerTrusted(X509Certificate[] xcs, String string)
          throws CertificateException {}

      public X509Certificate[] getAcceptedIssuers() {
        return null;
      }
    };
    final X509HostnameVerifier easyVerifier = new X509HostnameVerifier() {

      public boolean verify(String string, SSLSession ssls) {
        return true;
      }

      public void verify(String string, SSLSocket ssls) throws IOException {}

      public void verify(String string, String[] strings, String[] strings1) throws SSLException {}

      public void verify(String string, X509Certificate xc) throws SSLException {}

    };

    SSLContext ctx = null;
    try {
      ctx = SSLContext.getInstance("TLS");
      ctx.init(null, new TrustManager[] {easyTrustManager}, null);
    } catch (NoSuchAlgorithmException e) {
      throw new RuntimeException(e);
    } catch (KeyManagementException e) {
      throw new RuntimeException(e);
    }

    final SSLSocketFactory ssf = new SSLSocketFactory(ctx);
    ssf.setHostnameVerifier(easyVerifier);
    cm.getSchemeRegistry().register(new Scheme(HTTPS, ssf, HTTPS_PORT));

    return new DefaultHttpClient(cm);


  }