Create a match for a specific type of domain objects
@param domainObjectType
@return a DomainObjectMatch for a specific type of domain objects
501300
<T> DomainObjectMatch<T> createMatchInternal(Class<T> domainObjectType) {
		DomainObjectMatch<T> ret =APIAccess.createDomainObjectMatch(domainObjectType,
				this.queryExecutor.getDomainObjectMatches().size(),
				this.queryExecutor.getMappingInfo());
		this.queryExecutor.getDomainObjectMatches().add(ret);
		return ret;
	}
824084
@Trace(dispatcher = true)
	public Record createRecord(Long domainId, String name, String content, String type) throws GloboDnsException {
		NewRelic.setTransactionName(null, "/globodns/createRecord");
		if (domainId == null) {
			throw new GloboDnsException("Domain id cannot be null");
		}
		
		Record record = new Record();
		record.getGenericRecordAttributes().setDomainId(domainId);
		record.getGenericRecordAttributes().setName(name);
		record.getGenericRecordAttributes().setContent(content);
		record.getGenericRecordAttributes().setType(type.toUpperCase());
		
		GloboDnsRoot<Record> globoDnsRoot = this.post("/domains/" + domainId + "/records.json", record, false);
		if (globoDnsRoot == null) {
			throw new GloboDnsException("Invalid response");
		}
		return globoDnsRoot.getFirstObject();
	}
1031840
public static BinaryTypeSignature createObjectTypeSignature(String internalName) {
		if (internalName.charAt(internalName.length() - 1) != ';')
			return new BinaryObjectTypeSignature(internalName);
		return new BinaryGenericTypeSignature(internalName);
	}
740003
public Order ORDER(DomainObjectMatch<?> toOrder) {
		DomainObjectMatch<?> delegate = APIAccess.getDelegate(toOrder);
		DomainObjectMatch<?> match = delegate != null ? delegate : toOrder;
		OrderExpression oe = this.queryExecutor.getOrderFor(match);
		Order ret = APIAccess.createOrder(oe);
		QueryRecorder.recordInvocation(this, "ORDER", ret, QueryRecorder.placeHolder(match));
		return ret;
	}
1067703
static ObjectName createObjectName(final String domain, final PathAddress pathAddress) {
        return createObjectName(domain, pathAddress, null);
    }
1337747
public static <T> List<Option<T>> createOptions(Collection<T> domainObjects) { 
        List<Option<T>> options = new ArrayList<Option<T>>();
    
        for (T value : domainObjects) {
            String id = String.valueOf(getId(value));
            options.add(new Option<T>(id, value));
        }
    
        return options;
    }
152719
public ResultMatcher isObject() {
        return new AbstractResultMatcher(path, configuration) {
            public void doMatch(Object actual) {
                isPresent(actual);
                Node node = getNode(actual);
                if (node.getNodeType() != OBJECT) {
                    failOnType(node, "an object");
                }
            }
        };
    }
1271707
public List<DomainObjectType> getDomainObjectTypes() {
		List<DomainObjectType> resultList = new ArrayList<DomainObjectType>();
		GrNode infoNode = loadDomainInfoNode();
		GrProperty prop = infoNode.getProperty(DomainInfoLabel2ClassProperty);
		if (prop != null) {
			@SuppressWarnings("unchecked")
			List<String> val = (List<String>) prop.getValue();
			for (String str : val) {
				String[] c2l = str.split("=");
				resultList.add(new DomainObjectType(c2l[1], c2l[0]));
			}
		}
		return resultList;
	}
21172
public ObjectName createObjectName() {
        try {
            if (StringUtils.hasText(objectName)) {
                return new ObjectName(objectDomain + ":" + objectName);
            }

            if (type != null) {
                if (StringUtils.hasText(objectDomain)) {
                    return new ObjectName(objectDomain, "type", type.getSimpleName());
                }

                return new ObjectName(type.getPackage().getName(), "type", type.getSimpleName());
            }

            return new ObjectName(objectDomain, "name", name);
        } catch (NullPointerException | MalformedObjectNameException e) {
            throw new CitrusRuntimeException("Failed to create proper object name for managed bean", e);
        }
    }
1108165
public long countOf(DomainObjectMatch<?> match) {
		long ret;
		Object so = InternalAccess.getQueryExecutor(this.domainQuery).getMappingInfo()
				.getInternalDomainAccess().getSyncObject();
		if (so != null) {
			synchronized (so) {
				ret = intCountOf(match);
			}
		} else
			ret = intCountOf(match);
		return ret;
	}
654840
public <E> TerminalResult IN(DomainObjectMatch<E> domainObjects) {
		DomainObjectMatch<?> delegate = APIAccess.getDelegate(domainObjects);
		DomainObjectMatch<?> match = delegate != null ? delegate : domainObjects;
		getPredicateExpression().setOperator(Operator.IN);
		getPredicateExpression().setValue_2(match);
		TerminalResult ret = APIAccess.createTerminalResult(this.getPredicateExpression());
		QueryRecorder.recordInvocation(this, "IN", ret, QueryRecorder.placeHolder(match));
		return ret;
	}
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();
  }
665188
public static <T extends Tree> Matcher<T> isVoidType() {
    return new Matcher<T>() {
      @Override
      public boolean matches(T t, VisitorState state) {
        Type type = getType(t);
        return type != null && state.getTypes().isSameType(type, state.getSymtab().voidType);
      }
    };
  }
473923
@Override
    public ObjectType getObjectType(Object theObject)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            Tr.entry(tc, "getObjectType: " + theObject.getClass());
        }

        ObjectType objectType = ObjectType.NOT_AN_EJB;
        if (theObject instanceof javax.rmi.CORBA.Stub)
        {
            if (theObject instanceof EJBObject)
            {
                objectType = ObjectType.EJB_OBJECT;
            }
            else if (theObject instanceof EJBHome)
            {
                objectType = ObjectType.EJB_HOME;
            }
            else
            {
                objectType = ObjectType.CORBA_STUB;
            }
        }
        else if (theObject instanceof WrapperProxy) // F58064
        {
            if (theObject instanceof LocalBeanWrapperProxy)
            {
                // There is no sense in using heavyweight reflection to dig out the
                // WrapperProxyState since we can cheaply detect local bean.
                objectType = ObjectType.EJB_LOCAL_BEAN;
            }
            else
            {
                objectType = WrapperProxyState.getWrapperProxyState(theObject).getSerializerObjectType();
            }
        }
        else if (theObject instanceof EJSWrapperBase)
        {
            EJSWrapperBase wrapper = (EJSWrapperBase) theObject;
            WrapperInterface wInterface = wrapper.ivInterface;
            if (wInterface == WrapperInterface.BUSINESS_LOCAL)
            {
                objectType = ObjectType.EJB_BUSINESS_LOCAL;
            }
            else if (wInterface == WrapperInterface.LOCAL)
            {
                objectType = ObjectType.EJB_LOCAL_OBJECT;
            }
            else if (wInterface == WrapperInterface.LOCAL_HOME)
            {
                objectType = ObjectType.EJB_LOCAL_HOME;
            }
            else if (wInterface == WrapperInterface.BUSINESS_REMOTE)
            {
                objectType = ObjectType.EJB3_BUSINESS_REMOTE;
            }
            else if (wInterface == WrapperInterface.BUSINESS_RMI_REMOTE)
            {
                objectType = ObjectType.EJB3_BUSINESS_REMOTE;
            }
        }
        else if (theObject instanceof LocalBeanWrapper) // d609263
        {
            objectType = ObjectType.EJB_LOCAL_BEAN;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            Tr.exit(tc, "ObjectType = " + objectType);
        }

        return objectType;
    }
216920
@SuppressWarnings("unchecked")
    public DataMapper<Object, DBObject> getDataMapper(Class<?> domainObjectClass) {
        if (additionalDataMappers != null) {
            for (DataMapper<Object, DBObject> each : additionalDataMappers) {
                if (each.canMapToData(domainObjectClass)) {
                    return each;
                }
            }
        }
        if (dataMapper.canMapToData(domainObjectClass)) {
            return (DataMapper<Object, DBObject>) dataMapper;
        }
        // no matching
        return null;
    }
673482
public static <T> ObjectName getObjectName(final Class<T> clazz)
        {
        final String domain = clazz.getPackage().getName();
        final String className = clazz.getSimpleName();
        final String objectName = domain+":type="+className;
        LOG.debug("Returning object name: {}", objectName);
        try
            {
            return new ObjectName(objectName);
            }
        catch (final MalformedObjectNameException e)
            {
            // This should never, ever happen.
            LOG.error("Invalid ObjectName: "+objectName, e);
            throw new RuntimeException("Could not create ObjectName?", e);
            }
        }
978385
void expectActualObject(Node n, JSType type, String msg) {
    if (!type.isObject()) {
      mismatch(n, msg, type, OBJECT_TYPE);
    }
  }