Create a match for a list of domain objects which were retrieved by another query
@param domainObjects a list of domain objects which were retrieved by another query
@param domainObjectType the type of those domain objects
@return a DomainObjectMatch
9298
protected <T> DomainObjectMatch<T> createMatchForInternal(List<T> domainObjects,
			Class<T> domainObjectType) {
		DomainObjectMatch<T> ret = APIAccess.createDomainObjectMatch(domainObjectType,
				this.queryExecutor.getDomainObjectMatches().size(),
				this.queryExecutor.getMappingInfo());
		this.queryExecutor.getDomainObjectMatches().add(ret);
		FromPreviousQueryExpression pqe = new FromPreviousQueryExpression(
				ret, domainObjects);
		this.queryExecutor.addAstObject(pqe);
		return ret;
	}
203276
@SuppressWarnings("unused")
    public static Query createFor(Service service, Domain domain) {
        return new Query(service, domain, BROWSING_TIMEOUT);
    }
23225
@Override
    public <T> Query<T> createQuery(Class<T> entityType, Object queryObject) {
        Assert.notNull(entityType, "entityType must not null");
        Assert.notNull(queryObject, "queryObject must not null");
        return query(entityType, queryObject);
    }
758670
public static ObjectName getSystemObjectName(final String domainName,
                                               final String containerName,
                                               final Class theClass) throws MalformedObjectNameException {
    String tmp = domainName + ":" +
                 "type=" + theClass.getName() +
                 ",name=" + getRelativeName(containerName, theClass);
    return new ObjectName(tmp);
  }
914071
function setDomains(newDomains) {
    if (!isObject(newDomains)) {
        throw new InvalidException('newDomains should be an object', newDomains);
    }
    domainsMap = domainsMap.merge(newDomains);
}
433633
public List<Class<?>> getRawTypes(List<DomainObjectType> types) {
		List<Class<?>> resultList = new ArrayList<Class<?>>();
		for (DomainObjectType type : types) {
			resultList.add(type.getType());
		}
		return resultList;
	}
859432
public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
        throw SQLError.noSupport();
    }
1159044
public static function fromChildMatch(self $childMatchResult, $parentParams, $childRouteName)
    {
        if (!$childMatchResult->isSuccess()) {
            throw new DomainException('Child match must be a successful match result');
        }

        $matchResult = self::fromSuccess($childMatchResult->getParams() + $parentParams);
        $matchResult->routeName = $childRouteName;

        if (null !== $childMatchResult->getRouteName()) {
            $matchResult->routeName .= '/' . $childMatchResult->getRouteName();
        }

        return $matchResult;
    }
519079
public List<String> getDomainObjectTypeNames() {
		List<DomainObjectType> types = getDomainObjectTypes();
		List<String> typeNames = new ArrayList<String>(types.size());
		for (DomainObjectType typ : types) {
			typeNames.add(typ.getTypeName());
		}
		return typeNames;
	}
689111
public List<Object> match() {
        final IntMatchResults result = new IntMatchResults();
        if (matches(result)) {
            return result.getIntResultList();
        } else {
            return null;
        }
    }
715236
protected void checkInputClass(final Object domainObject) {
        final Class<?> actualInputType = domainObject.getClass();
        if(!(expectedInputType.isAssignableFrom(actualInputType))) {
            throw new IllegalArgumentException("The input document is required to be of type: " + expectedInputType.getName());
        }
    }
963687
private TagList createTagList(ObjectName name) {
    Map<String, String> props = name.getKeyPropertyList();
    SmallTagMap.Builder tagsBuilder = SmallTagMap.builder();
    for (Map.Entry<String, String> e : props.entrySet()) {
      String key = PROP_KEY_PREFIX + "." + e.getKey();
      tagsBuilder.add(Tags.newTag(key, e.getValue()));
    }
    tagsBuilder.add(Tags.newTag(DOMAIN_KEY, name.getDomain()));
    tagsBuilder.add(CLASS_TAG);
    if (defaultTags != null) {
      defaultTags.forEach(tagsBuilder::add);
    }
    return new BasicTagList(tagsBuilder.result());
  }
31782
private List<String> convertEDBObjectList(List<EDBObject> objects) {
        List<String> oids = new ArrayList<>();
        for (EDBObject object : objects) {
            oids.add(object.getOID());
        }
        return oids;
    }
241372
public Traverse TRAVERSE_FROM(DomainObjectMatch<?> start) {
		DomainObjectMatch<?> delegate = APIAccess.getDelegate(start);
		DomainObjectMatch<?> match = delegate != null ? delegate : start;
		TraversalExpression te = new TraversalExpression(match, this.queryExecutor);
		this.queryExecutor.addAstObject(te);
		Traverse ret = APIAccess.createTraverse(te);
		QueryRecorder.recordInvocation(this, "TRAVERSE_FROM", ret, QueryRecorder.placeHolder(match));
		return ret;
	}
432588
function getDomain(domain, callback) {
    getAll(function onGetAll(err, domains) {
      if (err) {
        return callback(err);
      }

      callback(null, domains.results.filter(function onGetDomain(domain_obj) {
        return domain_obj.domain == domain;
      })[0]);
    });
  }
1372236
@SuppressWarnings("unchecked")
    public static <T> T createProxyObject(Class<T> interfaceType, Object implementObject) {
        return (T) Proxy.newProxyInstance(
                implementObject.getClass().getClassLoader(),
                implementObject.getClass().getInterfaces(),
                new InvokeInterceptor(implementObject)
        );

    }
210424
public JSType createFunctionTypeWithInstanceType(ObjectType instanceType,
      JSType returnType, List<JSType> parameterTypes) {
    Node paramsNode = createParameters(parameterTypes.toArray(new JSType[parameterTypes.size()]));
    return FunctionType.builder(this)
        .withParamsNode(paramsNode)
        .withReturnType(returnType)
        .withTypeOfThis(instanceType)
        .build();
  }