Gets the SearchResultsObjectPool instance

@return the object pool
769490
public SearchResultsObjectPool getSearchResultsObjectPool() {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled()) {
            SibTr.entry(tc, "getSearchResultsObjectPool");
            SibTr.exit(tc, "getSearchResultsObjectPool", _connectionToMP);
        }
        return _searchResultsPool;
    }
366172
protected Object getObjectFromResultSet() throws PersistenceBrokerException
    {
        Object[] result = new Object[m_attributeCount];
        ReportQuery q =(ReportQuery) getQueryObject().getQuery();

        for (int i = 0; i < m_attributeCount; i++)
        {
            try
            {
                int jdbcType = m_jdbcTypes[i];
                String attr = q.getAttributes()[i];
                FieldDescriptor fld = (FieldDescriptor) q.getAttributeFieldDescriptors().get(attr);
                Object val =JdbcTypesHelper.getObjectFromColumn(getRsAndStmt().m_rs, new Integer(jdbcType), i + 1);
                
                if (fld != null && fld.getFieldConversion() != null)
                {
                    val = fld.getFieldConversion().sqlToJava(val);
                }
                result[i] = val;
            }
            catch (SQLException e)
            {
                throw new PersistenceBrokerException(e);
            }
        }
        return result;
    }
81681
private function getRaw()
    {
        if ($this->pool === null) {
            $this->pool = new ConnectionPool($this->keyspace, $this->servers);
        }
        return $this->pool->get();
    }
425753
public static Lookup get() {
        if (LOOKUP != null) {
            return LOOKUP;
        }
        synchronized (Lookup.class) {
            // allow for override of the Lookup.class
            String overrideClassName = System.getProperty(Lookup.class.getName());
            ClassLoader l = Thread.currentThread().getContextClassLoader();
            try {
                if (overrideClassName != null && !"".equals(overrideClassName)) {
                    LOOKUP = (Lookup) Class.forName(overrideClassName, true, l).newInstance();
                } else {
                    LOOKUP = new Lookup();
                }
            } catch (Exception e) {
                // ignore
            }
            // ServiceLoader and CDI are used by defaults, important that
            // CDI is used first so that beans are enabled for injection
            CdiLookup cdiLookup = new CdiLookup();
            LOOKUP.lookupProviders.add(cdiLookup);
            ServiceLoaderLookup serviceLoaderLookup = new ServiceLoaderLookup();
            LOOKUP.lookupProviders.add(serviceLoaderLookup);
            // Use ServiceLoader to find other LookupProviders
            Collection<LookupProvider> providers = serviceLoaderLookup
                    .lookupAll(LookupProvider.class);
            LOOKUP.lookupProviders.addAll(providers);
        }

        return LOOKUP;
    }
230518
@Trivial
    protected SubjectThreadContext getSubjectThreadContext() {
        ThreadLocal<SubjectThreadContext> currentThreadLocal = getThreadLocal();
        SubjectThreadContext subjectThreadContext = currentThreadLocal.get();
        if (subjectThreadContext == null) {
            subjectThreadContext = new SubjectThreadContext();
            currentThreadLocal.set(subjectThreadContext);
        }
        return subjectThreadContext;
    }
462751
RichByteBufferImpl getFromPool()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getFromPool");

      RichByteBufferImpl buffer = (RichByteBufferImpl) byteBufferWrapperPool.remove();
      if (buffer == null)
      {
         buffer = new RichByteBufferImpl();
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getFromPool", buffer);
      return buffer;
   }
1081768
public ConnectionPool getPool(String poolName)
            throws ConnectionPoolNotFoundException {
        ConnectionPool connectionPool = null;

        try {
            if (h_ConnectionPools.containsKey(poolName)) {
                connectionPool = h_ConnectionPools.get(poolName);
            } else {
                // Error: pool was never initialized or name could not be found
                throw new ConnectionPoolNotFoundException("Connection pool "
                        + "not found: " + poolName);
            }
        } catch (Throwable th) {
            throw new ConnectionPoolNotFoundException("The specified connection "
                    + "pool \""
                    + poolName
                    + "\" could not be found. The underlying "
                    + "error was a "
                    + th.getClass().getName()
                    + "The message was \""
                    + th.getMessage() + "\".");
        }

        return connectionPool;
    }
449962
public Map<String, ThreadPoolStatus> getStatusOfThreadPools(){
		Map<String, ThreadPoolStatus> result = new TreeMap<String, ThreadPoolStatus>();
		for (Map.Entry<String, ? extends ThreadPoolExecutor> entry: threadPools.entrySet()){
			ThreadPoolStatus status = new ThreadPoolStatus();
			status.setName(entry.getKey());
			ThreadPoolExecutor pool = entry.getValue();
			status.setActive(pool.getActiveCount());
			status.setKeepAliveSeconds(pool.getKeepAliveTime(TimeUnit.SECONDS));
			status.setLargestSize(pool.getLargestPoolSize());
			status.setMaxSize(pool.getMaximumPoolSize());
			status.setSize(pool.getPoolSize());
			status.setQueueLength(pool.getQueue().size());
			result.put(entry.getKey(), status);
		}
		return result;
	}
832271
@Override
    public Object getSingleResult()
    {
        // to fetch a single result form database.
        isSingleResult = true;
        List results = getResultList();
        isSingleResult = false;
        return onReturnResults(results);
    }
1247284
@SuppressWarnings("unchecked")
	public T get() {
		T result;

		if (uri != null) {
			if (classLoader == null) {
				classLoader = clazz.getClassLoader();
			}

			Endpoint clientEndpoint = new HTTPClientEndpoint(uri);
			if (logger != null) {
				clientEndpoint = new LoggerEndpoint(clientEndpoint, logger);
			}

			result = new FacadeEndpoint<T>(clientEndpoint, //
					classLoader, clazz, typeConverter, //
					additionalInterfaces.toArray(new Class<?>[additionalInterfaces.size()])) //
					.newProxy();
		} else {
			ObjectEndpoint endpoint = new ObjectEndpoint();
			endpoint.faultMapper(faultMapper);
			endpoint.typeConverter(typeConverter);
			endpoint.export(server, clazz);
			for (Class<?> i : additionalInterfaces) {
				endpoint.export(server, i);
			}
			result = (T) new HTTPServerEndpoint(endpoint);
		}

		return result;
	}
302927
public synchronized Collection<String> getPoolNames() {
    List<String> list = new ArrayList<String>();
    for (Pool pool: getPools()) {
      list.add(pool.getName());
    }
    Collections.sort(list);
    return list;
  }
1359237
public Iterable<ObjectResult> getFailedObjectResults() {
        List<ObjectResult> result = new ArrayList<>();
        for (ObjectResult objResult : m_objResultList) {
            if (objResult.isFailed()) {
                result.add(objResult);
            }
        }
        return result;
    }
1320441
public PooledObject<T> get() {
        T data = pool.pollLast();
        if (data == null) {
            data = function.get();
        }

        return new PooledObjectImpl<>(data, pool);
    }
397137
public ConnectionPool getPool() throws ConnectionPoolNotFoundException {
        ConnectionPool connectionPool = null;

        try {
            if (h_ConnectionPools.containsKey(defaultPoolName)) {
                connectionPool = h_ConnectionPools.get(defaultPoolName);
            } else {
                // Error: default pool was never initialized or could not be found
                throw new ConnectionPoolNotFoundException("Default connection pool "
                        + "not found: " + defaultPoolName);
            }

        } catch (Throwable th) {
            throw new ConnectionPoolNotFoundException("The default connection "
                    + "pool \"" + defaultPoolName
                    + "\" could not be found. The " + "underlying error was a "
                    + th.getClass().getName() + "The message was \""
                    + th.getMessage() + "\".");
        }

        return connectionPool;
    }
1189452
private GenericKeyedObjectPool createPool()
    {
        GenericKeyedObjectPool.Config conf = poolConfig.getKeyedObjectPoolConfig();
        if (log.isDebugEnabled())
            log.debug("PersistenceBroker pool will be setup with the following configuration " +
                    ToStringBuilder.reflectionToString(conf, ToStringStyle.MULTI_LINE_STYLE));
        GenericKeyedObjectPool pool = new GenericKeyedObjectPool(null, conf);
        pool.setFactory(new PersistenceBrokerFactoryDefaultImpl.PBKeyedPoolableObjectFactory(this, pool));
        return pool;
    }
655830
@Nonnull
    StringBuilder get() {
        if( pool.size() == 0 ) {
            return new StringBuilder();
        } else {
            StringBuilder builder = pool.pollLast();
            builder.setLength( 0 );
            return builder;
        }
    }
462998
protected Object getObjectFromResultSet() throws PersistenceBrokerException
    {

        try
        {
            // if all primitive attributes of the object are contained in the ResultSet
            // the fast direct mapping can be used
            return super.getObjectFromResultSet();
        }
                // if the full loading failed we assume that at least PK attributes are contained
                // in the ResultSet and perform a slower Identity based loading...
                // This may of course also fail and can throw another PersistenceBrokerException
        catch (PersistenceBrokerException e)
        {
            Identity oid = getIdentityFromResultSet();
            return getBroker().getObjectByIdentity(oid);
        }

    }