public String[] findNamedQueries(DomainClass domainClass) {
   if (domainClass.getGroovyClass() == null) {
     return NO_QUERIES;
   }
   String name = domainClass.getGroovyClass().getName();
   String[] queries = domainClassToQueries.get(name);
   if (queries == null) {
     queries = ensureInitialized(domainClass.getGroovyClass());
     synchronized (GrailsCore.get().getLockForProject(project)) {
       domainClassToQueries.put(name, queries);
     }
   }
   return queries;
 }
  private AnnotatedNode createMethodDeclaration(
      String finderName,
      String[] props,
      String[] comparators,
      String newPropName,
      String newComparator) {
    // need to determine number of parameters

    // first figure out how many properties we need to look at
    int numArgs = -1;
    if (newPropName != null) {
      for (int i = 0; i < props.length; i++) {
        if (props[i] == null) {
          props[i] = newPropName;
          numArgs = i + 1;
          break;
        }
      }
    }
    if (newComparator != null) {
      for (int i = 0; i < comparators.length; i++) {
        if (comparators[i] == null) {
          comparators[i] = newComparator;
          numArgs = i + 1;
          break;
        }
      }
    }

    List<Parameter> params = new ArrayList<Parameter>(2);
    // now go through each component and comparator.
    // determine the kind of parameters they require
    for (int i = 0; i < numArgs; i++) {
      ClassNode[] classNodes = COMPARATOR_ARGUMENT_MAP.get(comparators[i]);
      if (classNodes.length > 0) {
        String uncapitalized = uncapitalize(props[i]);
        params.add(new Parameter(classNodes[0], uncapitalized));
        if (classNodes.length == 2) {
          params.add(new Parameter(classNodes[1], uncapitalized + "1"));
        }
      }
    }

    MethodNode method =
        new MethodNode(
            finderName,
            Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC,
            createReturnType(finderName),
            params.toArray(new Parameter[params.size()]),
            NO_EXCEPTIONS,
            EMPTY_BLOCK);
    if (domain != null) {
      method.setDeclaringClass(domain.getGroovyClass());
    } else {
      method.setDeclaringClass(VariableScope.OBJECT_CLASS_NODE);
    }
    return method;
  }
 private Set<String> generateDomainProperties(DomainClass domain) {
   Assert.isNotNull(domain, "Domain class should not be null");
   List<PropertyNode> domainPropertiesNodes = domain.getDomainProperties();
   Set<String> properties = new HashSet<String>(domainPropertiesNodes.size() * 2);
   for (PropertyNode property : domainPropertiesNodes) {
     properties.add(capitalize(property.getName()));
   }
   return properties;
 }
 /**
  * Creates a valid declaration based on the name passed in
  *
  * @param finderName the name of the dynamic finder
  * @return A field declaration corresponding to the dynamic finder return a field and not a method
  *     so that components can be built up more easily
  */
 public FieldNode createFieldDeclaration(String finderName) {
   ClassNode declaring = domain != null ? domain.getGroovyClass() : null;
   if (declaring == null) {
     declaring = VariableScope.OBJECT_CLASS_NODE;
   }
   FieldNode field =
       new FieldNode(
           finderName,
           Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC,
           createReturnType(finderName),
           declaring,
           null);
   field.setDeclaringClass(declaring);
   return field;
 }
 /**
  * @param finderName
  * @return
  */
 private ClassNode createReturnType(String finderName) {
   if (finderName.startsWith("countBy")) {
     return VariableScope.INTEGER_CLASS_NODE;
   } else {
     ClassNode groovyClass = domain != null ? domain.getGroovyClass() : null;
     if (groovyClass == null) {
       groovyClass = VariableScope.OBJECT_CLASS_NODE;
     }
     if (finderName.startsWith("findAllBy") || finderName.startsWith("listOrderBy")) {
       ClassNode list = VariableScope.clonedList();
       ClassNode thisClass = groovyClass;
       list.getGenericsTypes()[0].setType(thisClass);
       list.getGenericsTypes()[0].setName(thisClass.getName());
       list.getGenericsTypes()[0].setUpperBounds(null);
       return list;
     } else {
       return groovyClass;
     }
   }
 }