Example usage for java.lang.reflect Modifier PRIVATE

List of usage examples for java.lang.reflect Modifier PRIVATE

Introduction

In this page you can find the example usage for java.lang.reflect Modifier PRIVATE.

Prototype

int PRIVATE

To view the source code for java.lang.reflect Modifier PRIVATE.

Click Source Link

Document

The int value representing the private modifier.

Usage

From source file:com.link_intersystems.lang.reflect.criteria.MemberCriteriaTest.java

@Test(expected = IllegalArgumentException.class)
public void illegalModifierPrivate() {
    memberCriteria.withModifiers(Modifier.PRIVATE);
}

From source file:org.springframework.flex.roo.addon.ui.FormTemplateTests.java

@Test
public void testFormWithDateFieldSingleValidation() throws SAXException, IOException {
    ActionScriptType entityType = new ActionScriptType("com.foo.Person");
    StringTemplate listViewTemplate = templateGroup
            .getInstanceOf("org/springframework/flex/roo/addon/ui/entity_form");
    listViewTemplate.setAttribute("entityType", entityType);
    listViewTemplate.setAttribute("flexScaffoldMetadata", flexScaffoldMetadata);

    List<FieldMetadata> elegibleFields = new ArrayList<FieldMetadata>();
    AnnotationMetadataBuilder annotation = new AnnotationMetadataBuilder(
            new JavaType("javax.validation.constraints.NotNull"), Collections.EMPTY_LIST);
    FieldMetadata field = new FieldMetadataBuilder("MID:person#1", Modifier.PRIVATE,
            Collections.singletonList(annotation), new JavaSymbolName("birthday"),
            new JavaType("java.util.Date")).build();
    elegibleFields.add(field);//from  w ww.ja  v  a  2  s  . c  om
    listViewTemplate.setAttribute("fields", FlexUIMetadataProvider.wrapFields(elegibleFields));

    String result = listViewTemplate.toString();
    log.debug(result);

    assertTrue(result.contains("mx:DateValidator"));
    assertTrue(result.contains("mx:DateField"));

    ByteArrayInputStream stream = new ByteArrayInputStream(result.getBytes("UTF-8"));
    XmlUtils.getDocumentBuilder().parse(stream);
}

From source file:org.eclipse.buildship.docs.source.SourceMetaDataVisitor.java

private int extractModifiers(GroovySourceAST ast) {
    GroovySourceAST modifiers = ast.childOfType(MODIFIERS);
    if (modifiers == null) {
        return 0;
    }/*from w  ww . j ava 2  s .c  o  m*/
    int modifierFlags = 0;
    for (GroovySourceAST child = (GroovySourceAST) modifiers
            .getFirstChild(); child != null; child = (GroovySourceAST) child.getNextSibling()) {
        switch (child.getType()) {
        case LITERAL_private:
            modifierFlags |= Modifier.PRIVATE;
            break;
        case LITERAL_protected:
            modifierFlags |= Modifier.PROTECTED;
            break;
        case LITERAL_public:
            modifierFlags |= Modifier.PUBLIC;
            break;
        case FINAL:
            modifierFlags |= Modifier.FINAL;
            break;
        case LITERAL_static:
            modifierFlags |= Modifier.STATIC;
            break;
        case ABSTRACT:
            modifierFlags |= Modifier.ABSTRACT;
            break;
        }
    }
    return modifierFlags;
}

From source file:org.codehaus.groovy.grails.compiler.injection.test.TestMixinTransformation.java

static protected FieldNode addLegacyMixinFieldIfNonExistent(ClassNode classNode, ClassNode fieldType,
        String fieldName) {/*from  w w  w  .  j ava  2  s .c o m*/
    ClassNode targetAwareInterface = GrailsASTUtils.findInterface(fieldType,
            new ClassNode(TestMixinTargetAware.class).getPlainNodeReference());
    if (classNode != null && classNode.getField(fieldName) == null) {
        Expression constructorArgument = new ArgumentListExpression();
        if (targetAwareInterface != null) {
            MapExpression namedArguments = new MapExpression();
            namedArguments.addMapEntryExpression(
                    new MapEntryExpression(new ConstantExpression("target"), new VariableExpression("this")));
            constructorArgument = namedArguments;
        }
        return classNode.addField(fieldName, Modifier.PRIVATE, fieldType,
                new ConstructorCallExpression(fieldType, constructorArgument));
    }
    return null;
}

From source file:org.gvnix.flex.ui.FormTemplateTests.java

@Test
public void testFormWithOneToOneRelationship() throws SAXException, IOException {
    ActionScriptType entityType = new ActionScriptType("com.foo.Person");
    StringTemplate listViewTemplate = templateGroup.getInstanceOf("org/gvnix/flex/roo/addon/ui/entity_form");
    listViewTemplate.setAttribute("entityType", entityType);
    listViewTemplate.setAttribute("flexScaffoldMetadata", flexScaffoldMetadata);

    List<FieldMetadata> elegibleFields = new ArrayList<FieldMetadata>();
    List<AnnotationAttributeValue<?>> attrs = new ArrayList<AnnotationAttributeValue<?>>();
    attrs.add(new ClassAttributeValue(new JavaSymbolName("targetEntity"), new JavaType("com.foo.Address")));
    AnnotationMetadataBuilder annotation = new AnnotationMetadataBuilder(
            new JavaType("javax.persistence.OneToOne"), attrs);
    FieldMetadata field = new FieldMetadataBuilder("MID:person#1", Modifier.PRIVATE,
            Collections.singletonList(annotation), new JavaSymbolName("currentAddress"),
            new JavaType("com.foo.Address")).build();
    elegibleFields.add(field);// w  w w.  ja v  a  2s. c  o  m
    listViewTemplate.setAttribute("fields", FlexUIMetadataProvider.wrapFields(elegibleFields));
    listViewTemplate.setAttribute("relatedTypes",
            Collections.singletonList(new FlexUIMetadataProvider.RelatedTypeWrapper(
                    new ActionScriptType("com.foo.Address"), elegibleFields, true)));
    Map<String, String> labelFields = new HashMap<String, String>();
    labelFields.put("currentAddress", "street");
    listViewTemplate.setAttribute("labelFields", labelFields);

    String result = listViewTemplate.toString();
    log.debug(result);

    assertTrue(result.contains("import com.foo.Address;"));
    assertTrue(result.contains("person.currentAddress = currentAddressInput.selectedItem;"));

    ByteArrayInputStream stream = new ByteArrayInputStream(result.getBytes("UTF-8"));
    XmlUtils.getDocumentBuilder().parse(stream);
}

From source file:org.springframework.flex.roo.addon.ui.FormTemplateTests.java

@Test
public void testFormWithOneToOneRelationship() throws SAXException, IOException {
    ActionScriptType entityType = new ActionScriptType("com.foo.Person");
    StringTemplate listViewTemplate = templateGroup
            .getInstanceOf("org/springframework/flex/roo/addon/ui/entity_form");
    listViewTemplate.setAttribute("entityType", entityType);
    listViewTemplate.setAttribute("flexScaffoldMetadata", flexScaffoldMetadata);

    List<FieldMetadata> elegibleFields = new ArrayList<FieldMetadata>();
    List<AnnotationAttributeValue<?>> attrs = new ArrayList<AnnotationAttributeValue<?>>();
    attrs.add(new ClassAttributeValue(new JavaSymbolName("targetEntity"), new JavaType("com.foo.Address")));
    AnnotationMetadataBuilder annotation = new AnnotationMetadataBuilder(
            new JavaType("javax.persistence.OneToOne"), attrs);
    FieldMetadata field = new FieldMetadataBuilder("MID:person#1", Modifier.PRIVATE,
            Collections.singletonList(annotation), new JavaSymbolName("currentAddress"),
            new JavaType("com.foo.Address")).build();
    elegibleFields.add(field);//from www.ja  v  a 2  s  .  com
    listViewTemplate.setAttribute("fields", FlexUIMetadataProvider.wrapFields(elegibleFields));
    listViewTemplate.setAttribute("relatedTypes",
            Collections.singletonList(new FlexUIMetadataProvider.RelatedTypeWrapper(
                    new ActionScriptType("com.foo.Address"), elegibleFields, true)));
    Map<String, String> labelFields = new HashMap<String, String>();
    labelFields.put("currentAddress", "street");
    listViewTemplate.setAttribute("labelFields", labelFields);

    String result = listViewTemplate.toString();
    log.debug(result);

    assertTrue(result.contains("import com.foo.Address;"));
    assertTrue(result.contains("person.currentAddress = currentAddressInput.selectedItem;"));

    ByteArrayInputStream stream = new ByteArrayInputStream(result.getBytes("UTF-8"));
    XmlUtils.getDocumentBuilder().parse(stream);
}

From source file:com.industrieit.ohr.OHRJavassister.java

public static Class ohr(Class cll) {
    try {/* w  w  w  .  j a v  a  2 s.  com*/
        //System.out.println("++++++++++ "+cll.getName());
        /*if (cll.getName().startsWith("ohr."))
        {
        throw new RuntimeException(cll.getName());
        }*/
        if (processed2.containsKey(cll)) {
            return processed2.get(cll);
        }

        HashSet<Long> handleOffsets = new HashSet<Long>();

        String cnam = cll.getName();
        if (!cnam.startsWith("ohr.")) {
            cnam = "ohr." + cll.getName();
            //cnam=cnam.substring(4);
        }

        Class cl = Class.forName(cnam.substring(4));

        int clnumber = incrementClsCounter();

        List<Integer> owned = new ArrayList<Integer>();

        //remove the old implementation if its around from another process
        String fname = "target/classes/" + cnam.replace(".", "/") + ".class";
        System.out.println("deleted" + fname + " " + (new File(fname).delete()));

        if (!Modifier.isAbstract(cl.getModifiers())) {
            throw new RuntimeException("not an abstract class " + cl.getName());
        }

        System.out.println("processing ohr " + cnam);

        CtClass bc = getDefault().getCtClass(cl.getName());
        CtClass cc = getDefault().makeClass(cnam, bc);

        StringBuilder initBuilder = new StringBuilder();
        initBuilder.append("public void internalInit() {\n");

        StringBuilder constructBuilder = new StringBuilder();
        constructBuilder.append("{");

        String intname = OHRBase.class.getName();
        System.out.println("intername is " + intname);

        CtClass ci = getDefault().getCtClass(intname);
        CtClass extern = getDefault().getCtClass(Externalizable.class.getName());

        //cc.addInterface(ci);
        cc.setInterfaces(new CtClass[] { ci, extern });
        cc.setSuperclass(bc);

        //add base implmenetation methods and properties
        setBaseMixinsPre(cc, false);

        //first long for id and other stuff
        long offset = 8;

        BeanInfo bi = Introspector.getBeanInfo(cl);
        PropertyDescriptor[] pds = bi.getPropertyDescriptors();

        for (int co = 0; co < propertyOrdering.length; co++) {
            Class cprop = propertyOrdering[co];

            for (int i = 0; i < pds.length; i++) {
                // Get property name
                String propName = pds[i].getName();

                if (propName.equals("class")) {
                    continue;
                }

                String typ = pds[i].getPropertyType().getName();
                Class type = pds[i].getPropertyType();
                //if (propName.startsWith("fath"))
                //PL.pl("[[[[["+type+" "+propName+" "+cprop);
                if (cprop == Object.class) {
                    //handle refs only
                    if (type.isPrimitive()) {
                        continue;
                    }
                    if (type == String.class) {
                        continue;
                    }
                    if (type == CharSequence.class) {
                        continue;
                    }
                    if (type == OHRLongArray.class) {
                        continue;
                    }
                    if (type == OHRIntArray.class) {
                        continue;
                    }
                    if (type == OHRShortArray.class) {
                        continue;
                    }
                    if (type == OHRByteArray.class) {
                        continue;
                    }
                    if (type == OHRBooleanArray.class) {
                        continue;
                    }
                    if (type == OHRDoubleArray.class) {
                        continue;
                    }
                    if (type == OHRFloatArray.class) {
                        continue;
                    }
                } else if (cprop != type) {
                    //PL.pl("skipping "+type+" "+cprop);
                    continue;
                }
                //PL.pl("[[[[[    " + type + " - " + propName + " - " + cprop);
                //System.out.println("--prop--" + propName);

                String rname = pds[i].getReadMethod().getName();
                String wname = null;
                if (pds[i].getWriteMethod() != null) {
                    wname = pds[i].getWriteMethod().getName();
                }

                boolean reifread = isMethodReifAnnotated(pds[i].getReadMethod());
                boolean reifwrite = isMethodReifAnnotated(pds[i].getWriteMethod());

                String wcons = getConsistencyAsString(pds[i].getWriteMethod());
                String rcons = getConsistencyAsString(pds[i].getReadMethod());

                System.out.println("TYPE " + pds[i].getPropertyType().getName() + " "
                        + pds[i].getPropertyType().getInterfaces());

                if (pds[i].getPropertyType() == String.class && isInlineString(pds[i])) {
                    //NOTE - only for inline strings - normal strings are handled as extrefs like any other object
                    System.out.println("ITS An inline string!!!!");

                    int length = pds[i].getWriteMethod().getAnnotation(InlineStringReify.class).length();
                    boolean trim = pds[i].getWriteMethod().getAnnotation(InlineStringReify.class)
                            .trimOverflow();
                    boolean ascii = pds[i].getWriteMethod().getAnnotation(InlineStringReify.class).asciiOnly();

                    String wmeth = "public void " + wname + "(" + typ + " o) { ohwritestr" + wcons + "("
                            + offset + "l,o," + length + "," + trim + "," + ascii + "); }";
                    //add setter
                    CtMethod wmethod = CtNewMethod.make(wmeth, cc);

                    cc.addMethod(wmethod);

                    System.out.println(wmeth);
                    String rmeth = "public " + typ + " " + rname + "() { return (" + typ + ") ohreadstr" + rcons
                            + "(" + offset + "l," + ascii + "); }";
                    //add setter
                    CtMethod rmethod = CtNewMethod.make(rmeth, cc);
                    //rmethod.getMethodInfo().addAttribute(attr);
                    cc.addMethod(rmethod);
                    System.out.println(rmeth);

                    int bytesperchar = ascii ? 1 : 2;

                    //pad to 16 bits
                    int ll = 4 + length * bytesperchar;
                    if (ll % 2 != 0) {
                        ll++;
                    }
                    offset += ll; //lebgth marker as well as unicode 16 encoded characters
                } else if (pds[i].getPropertyType() == CharSequence.class && isInlineString(pds[i])) {
                    //NOTE - only for inline strings - normal strings are handled as extrefs like any other object
                    System.out.println("ITS An inline charsequence!!!!");

                    int length = pds[i].getWriteMethod().getAnnotation(InlineStringReify.class).length();
                    boolean trim = pds[i].getWriteMethod().getAnnotation(InlineStringReify.class)
                            .trimOverflow();
                    boolean ascii = pds[i].getWriteMethod().getAnnotation(InlineStringReify.class).asciiOnly();
                    String wmeth = "public void " + wname + "(" + typ + " o) { ohwritestr" + wcons + "("
                            + offset + "l,o," + length + "," + trim + "," + ascii + "); }";
                    //add setter
                    CtMethod wmethod = CtNewMethod.make(wmeth, cc);

                    cc.addMethod(wmethod);

                    System.out.println(wmeth);
                    String rmeth = "public " + typ + " " + rname + "() { return (" + typ + ") ohreadcs" + rcons
                            + "(" + offset + "l," + ascii + "); }";
                    //add setter
                    CtMethod rmethod = CtNewMethod.make(rmeth, cc);
                    //rmethod.getMethodInfo().addAttribute(attr);
                    cc.addMethod(rmethod);
                    System.out.println(rmeth);

                    int bytesperchar = ascii ? 1 : 2;
                    //pad to 8 byte boundary!
                    int ll = (int) Math.ceil((4.0 + length * bytesperchar) / 8) * 8;
                    offset += ll; //lebgth marker as well as unicode 16 encoded characters
                } else if ((pds[i].getPropertyType() == OHRLongArray.class
                        || pds[i].getPropertyType() == OHRIntArray.class
                        || pds[i].getPropertyType() == OHRShortArray.class
                        || pds[i].getPropertyType() == OHRByteArray.class
                        || pds[i].getPropertyType() == OHRFloatArray.class
                        || pds[i].getPropertyType() == OHRDoubleArray.class
                        || pds[i].getPropertyType() == OHRBooleanArray.class)
                        && pds[i].getReadMethod().isAnnotationPresent(InlineArrayReify.class)) {

                    int bitsperitem = 0;
                    String cldef = null;
                    Class at = pds[i].getPropertyType();
                    boolean unchecked = pds[i].getReadMethod().isAnnotationPresent(UncheckedBoundsXXX.class);
                    if (at == OHRLongArray.class) {
                        bitsperitem = 8 * 8;
                        cldef = LongInlineOHRArray.class.getName();
                    } else if (at == OHRIntArray.class) {
                        bitsperitem = 4 * 8;
                        //cldef=IntInlineOHRArrayCop.class.getName();
                        if (unchecked) {
                            cldef = IntInlineOHRArrayUnchecked.class.getName();
                        } else {
                            cldef = IntInlineOHRArray.class.getName();
                        }
                    }
                    if (at == OHRDoubleArray.class) {
                        bitsperitem = 8 * 8;
                        cldef = DoubleInlineOHRArray.class.getName();
                    }
                    if (at == OHRFloatArray.class) {
                        bitsperitem = 4 * 8;
                        cldef = FloatInlineOHRArray.class.getName();
                    }
                    if (at == OHRShortArray.class) {
                        bitsperitem = 2 * 8;
                        cldef = ShortInlineOHRArray.class.getName();
                    }
                    if (at == OHRByteArray.class) {
                        bitsperitem = 1 * 8;
                        cldef = ByteInlineOHRArray.class.getName();
                    }
                    if (at == OHRBooleanArray.class) {
                        bitsperitem = 1;
                        cldef = BooleanInlineOHRArray.class.getName();
                    }
                    //NOTE - only for inline strings - normal strings are handled as extrefs like any other object
                    System.out.println("ITS An inline array!!!!");

                    int length = pds[i].getReadMethod().getAnnotation(InlineArrayReify.class).length();

                    long bytealloc = OHRInlineArrayHandler.getGenericArrayAllocationSize(bitsperitem, length);

                    //PL.pl("byte allocation for logn array length "+length+" "+bytealloc);

                    CtClass ctc = getDefault().getCtClass(cldef);

                    String varname = "var" + i;
                    CtField cf = new CtField(ctc, varname, cc);
                    cf.setModifiers(Modifier.PRIVATE);
                    cc.addField(cf);

                    //add data to constructor
                    initBuilder.append(
                            "com.industrieit.ohr.OHRInlineArrayHandler.initialiseInlineGenericArray(this.basePtr+"
                                    + offset + "l," + length + "l," + bitsperitem + ");\n");
                    constructBuilder.append(varname + "=new " + cldef + "(this," + offset + "l);\n");

                    //+ "//this.basePtr"+offset+"l);");

                    //String wmeth = "public void " + wname + "(" + typ + " o) { throw new java.lang.RuntimeException(\"not supported\"); }";
                    //add setter
                    //CtMethod wmethod = CtNewMethod.make(wmeth, cc);

                    //cc.addMethod(wmethod);

                    //System.out.println(wmeth);
                    String rmeth = "public " + typ + " " + rname + "() { return " + varname + "; }";
                    //add setter
                    CtMethod rmethod = CtNewMethod.make(rmeth, cc);
                    //rmethod.getMethodInfo().addAttribute(attr);
                    cc.addMethod(rmethod);
                    System.out.println("||||||||" + rmeth + "|||||||||");

                    offset += bytealloc;
                } else if (pds[i].getPropertyType().isPrimitive()) {
                    //PL.pl("ITS A PRIMITIVE!");
                    int vv = 0;
                    if (cprop == long.class) {
                        vv = 8;
                    }
                    if (cprop == double.class) {
                        vv = 8;
                    }
                    if (cprop == int.class) {
                        vv = 4;
                    }
                    if (cprop == float.class) {
                        vv = 4;
                    }
                    if (cprop == short.class) {
                        vv = 2;
                    }
                    if (cprop == byte.class) {
                        vv = 1;
                    }

                    System.out.println(
                            "for " + pds[i].getName() + " typ is " + pds[i].getPropertyType().getName());

                    String wmeth = "public void " + wname + "(" + typ + " o) { ohwrite" + wcons + "(" + offset
                            + "l,o); }";
                    //add setter

                    //ConstPool constpool = cc.getClassFile().getConstPool();

                    if (reifwrite) {
                        CtMethod wmethod = CtNewMethod.make(wmeth, cc);
                        cc.addMethod(wmethod);
                        System.out.println("&&&&&&&" + wmeth);
                    }

                    String rmeth = "public " + typ + " " + rname + "() { return (" + typ + ") ohread" + typ
                            + rcons + "(" + offset + "l); }";
                    //add setter

                    //rmethod.getMethodInfo().addAttribute(attr);
                    if (reifread) {
                        CtMethod rmethod = CtNewMethod.make(rmeth, cc);
                        cc.addMethod(rmethod);
                        System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&" + rmeth + vv);
                    }

                    offset += vv;
                } else {
                    System.out.println("ITS AN ASSUMED REIFY!!!");

                    if (pds[i].getWriteMethod().isAnnotationPresent(Owned.class)) {
                        owned.add(i);
                    }
                    //CtClass tc = getDefault().getCtClass(pds[i].getPropertyType().getName());
                    CtClass tc = getDefault().getCtClass(OHRBase.class.getName());
                    //String fnam="ohrt"+i;
                    //CtField f = new CtField(tc, fnam, cc);
                    //f.setModifiers(Modifier.PROTECTED);
                    //cc.addField(f);
                    //store by reify
                    //handleOffsets.add(offset);
                    String wmeth = "public void " + wname + "(" + typ + " o) { ohwritere" + wcons + "(" + offset
                            + "l,o); }";
                    //add setter
                    CtMethod wmethod = CtNewMethod.make(wmeth, cc);

                    if (reifwrite) {
                        cc.addMethod(wmethod);
                    }

                    System.out.println(wmeth);
                    //String rmeth = "public " + typ + " " + rname + "() { return (" + typ + ") ohreadre(" + offset + "l," + typ + ".class); }";
                    String rmeth = "public " + typ + " " + rname + "() { return (" + typ + ") ohreadre" + rcons
                            + "(" + offset + "l);  };";
                    //add setter
                    CtMethod rmethod = CtNewMethod.make(rmeth, cc);
                    //rmethod.getMethodInfo().addAttribute(attr);
                    if (reifread) {
                        cc.addMethod(rmethod);
                    }
                    System.out.println(rmeth);
                    handleOffsets.add(offset);
                    offset += 8;
                }

                /* if (!isReif(type)) {
                        
                PL.pl(""+pds[i].getName()+" is a non reified handle!!!!");
                //store by handle
                handleOffsets.add(offset);
                String wmeth = "public void " + wname + "(" + typ + " o) { ohwritehand(" + offset + "l,o); }";
                //add setter
                CtMethod wmethod = CtNewMethod.make(wmeth, cc);
                        
                if (reifwrite) {
                    cc.addMethod(wmethod);
                }
                        
                System.out.println(wmeth);
                String rmeth = "public " + typ + " " + rname + "() { return (" + typ + ") ohreadhand(" + offset + "l); }";
                //add setter
                        
                CtMethod rmethod = CtNewMethod.make(rmeth, cc);
                //rmethod.getMethodInfo().addAttribute(attr);
                if (reifread) {
                    cc.addMethod(rmethod);
                }
                System.out.println(rmeth);
                }*/
            }

            //PL.pl("offset is "+offset);

        }
        //offset+=8;
        //ok create the get handleoffsets method

        //print out total byts allocated
        //PL.pl("%%%%%%%%%% TOTAL BYTES = " + offset);

        StringBuilder sb = new StringBuilder();
        sb.append("public long[] handleOffsets() { ");
        sb.append("long a[] = new long[").append(handleOffsets.size()).append("];");
        int c = 0;
        for (long l : handleOffsets) {
            sb.append("a[").append(c).append("]=").append(l).append("l;");
            c++;
        }
        sb.append("return a; }");

        System.out.println(sb.toString());
        CtMethod om = CtNewMethod.make(sb.toString(), cc);
        cc.addMethod(om);

        String sizem = "public long gsize() { return " + (offset) + "l; }";
        //PL.pl(sizem);

        CtMethod sm = CtNewMethod.make(sizem, cc);
        cc.addMethod(sm);

        //add clsid
        CtMethod cmid = CtNewMethod.make("public int ohclassId() { return " + clnumber + "; }", cc);
        cc.addMethod(cmid);

        setBaseMixinsPost(cc, false, owned, pds, constructBuilder, initBuilder);

        cc.writeFile("target/classes");

        /*for (Method me : cc.toClass().getDeclaredMethods()) { //test print, ok
         //System.out.println(me.getName());
         }*/

        Class ppp = Class.forName(cnam);
        Field f = ppp.getDeclaredField("u");
        f.setAccessible(true);
        f.set(ppp.newInstance(), USafe.getUnsafe());
        //synchronized (mutex)
        //{
        processed2.put(cl, ppp);
        processed2.put(ppp, ppp);
        cls[clnumber] = ppp;
        return ppp;
        //}

    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:org.gvnix.addon.gva.security.providers.safe.SafeSecurityProviderMetadata.java

/**
 * Gets <code>convertWSInfoToUser</code> method. <br>
 * /*from w ww  .  j  a v a 2s . co m*/
 * @return
 */
private MethodMetadata getConvertWSInfoToUserMethod() {
    // Define method parameter types
    List<AnnotatedJavaType> parameterTypes = AnnotatedJavaType.convertFromJavaTypes(
            new JavaType("es.gva.dgm.ayf.war.definitions.v2u00.GetInformacionWSResponse"), JavaType.STRING,
            new JavaType(JAVA_UTIL_LIST, 0, DataType.TYPE, null, Arrays.asList(new JavaType(PERMISO_APP))));

    // Check if a method with the same signature already exists in the
    // target type
    final MethodMetadata method = methodExists(CONVERT_WS_METHOD, parameterTypes);
    if (method != null) {
        // If it already exists, just return the method and omit its
        // generation via the ITD
        return method;
    }

    // Define method annotations
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();

    // Define method throws types
    List<JavaType> throwsTypes = new ArrayList<JavaType>();

    // Define method parameter names
    List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>();
    parameterNames.add(new JavaSymbolName("userFromWS"));
    parameterNames.add(new JavaSymbolName("username"));
    parameterNames.add(new JavaSymbolName("listPermisos"));

    // Create the method body
    InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
    buildConvertWSInfoToUserMethodBody(bodyBuilder);

    // Use the MethodMetadataBuilder for easy creation of MethodMetadata
    MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PRIVATE,
            CONVERT_WS_METHOD, new JavaType("SafeUser"), parameterTypes, parameterNames, bodyBuilder);
    methodBuilder.setAnnotations(annotations);
    methodBuilder.setThrowsTypes(throwsTypes);

    return methodBuilder.build(); // Build and return a MethodMetadata
    // instance
}

From source file:org.gvnix.addon.gva.security.providers.safe.SafeSecurityProviderMetadata.java

/**
 * Gets <code>convertWSInfoToUserTodasAplicaciones</code> method. <br>
 * //  www .  j  av a2 s .c o m
 * @return
 */
private MethodMetadata getConvertWSInfoToUserTodasAplicacionesMethod() {
    // Define method parameter types
    List<AnnotatedJavaType> parameterTypes = AnnotatedJavaType.convertFromJavaTypes(
            new JavaType("es.gva.dgm.ayf.war.definitions.v2u00.GetInformacionWSResponse"), JavaType.STRING,
            new JavaType(JAVA_UTIL_LIST, 0, DataType.TYPE, null, Arrays.asList(new JavaType(PERMISO))));

    // Check if a method with the same signature already exists in the
    // target type
    final MethodMetadata method = methodExists(CONVERT_WS_TODAS_METHOD, parameterTypes);
    if (method != null) {
        // If it already exists, just return the method and omit its
        // generation via the ITD
        return method;
    }

    // Define method annotations
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();

    // Define method throws types
    List<JavaType> throwsTypes = new ArrayList<JavaType>();

    // Define method parameter names
    List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>();
    parameterNames.add(new JavaSymbolName("userFromWS"));
    parameterNames.add(new JavaSymbolName("username"));
    parameterNames.add(new JavaSymbolName("listPermisos"));

    // Create the method body
    InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
    buildConvertWSInfoToUserTodasAplicacionesMethodBody(bodyBuilder);

    // Use the MethodMetadataBuilder for easy creation of MethodMetadata
    MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PRIVATE,
            CONVERT_WS_TODAS_METHOD, new JavaType("SafeUser"), parameterTypes, parameterNames, bodyBuilder);
    methodBuilder.setAnnotations(annotations);
    methodBuilder.setThrowsTypes(throwsTypes);

    return methodBuilder.build(); // Build and return a MethodMetadata
    // instance
}

From source file:com.link_intersystems.lang.reflect.criteria.MemberCriteria.java

@SuppressWarnings("unchecked")
protected Iterator<T> applyAccessAndNamePredicates(Iterator<T> iterator) {
    List<Predicate<?>> predicates = new ArrayList<Predicate<?>>();

    int accessModifiers = 0;
    Collection<AccessType> accesses = getAccesses();
    for (AccessType access : accesses) {
        switch (access) {
        case PUBLIC:
            accessModifiers |= Modifier.PUBLIC;
            break;
        case PRIVATE:
            accessModifiers |= Modifier.PRIVATE;
            break;
        case PROTECTED:
            accessModifiers |= Modifier.PROTECTED;
            break;
        default:/*from   www  .j a  v a  2s  . c o  m*/
            break;
        }
    }
    Predicate<Member> accessModifierPredicate = new MemberModifierPredicate(accessModifiers,
            Match.AT_LEAST_ONE);

    if (accesses.contains(AccessType.DEFAULT)) {
        accessModifierPredicate = OrPredicate.orPredicate(accessModifierPredicate,
                NotPredicate.notPredicate(new MemberModifierPredicate(
                        Modifier.PRIVATE | Modifier.PUBLIC | Modifier.PROTECTED, Match.AT_LEAST_ONE)));
    }

    predicates.add(accessModifierPredicate);

    int modifiers = getModifiers();
    if (modifiers != 0) {
        predicates.add(new MemberModifierPredicate(modifiers, Match.AT_LEAST_ALL));
    }

    String name = getName();
    if (name != null) {
        predicates.add(ReflectFacade.getMemberNamePredicate(name));
    }

    Pattern pattern = getPattern();
    if (pattern != null) {
        predicates.add(ReflectFacade.getMemberNamePatternPredicate(pattern));
    }
    Predicate<T> allPredicate = AllPredicate.allPredicate((Collection<? extends Predicate<T>>) predicates);
    iterator = IteratorUtils.filteredIterator(iterator, allPredicate);
    return iterator;
}