TODO To complete.

@param cls
@param st
167633
private boolean isImplements(final EClass cls, EGenericType st) {
        final EClass cls2 = (EClass) st.getEClassifier();

        return !cls.isInterface() && cls2.isInterface();
    }
464650
public void setValue(String st) {
        this.value = SyntaxDEFactory.createSyntaxDE(getType(), getPath(), st, minsize, maxsize);
    }
1285174
public static void main(String args[]) {
        Statement stmts[] = null;
        try {
            stmts = getStatements(args[0]);
        } catch (Throwable e) {
            System.out.println(e.getMessage());
            return;
        }
        for (Statement s : stmts) {
            System.out.print(s.statement);
        }
    }
194626
protected void init(Class<T> cls, Key ... keys) {
    	
		// get the columns 
        List<String> targetColumns = new ArrayList<String>();
        Class<?> clazz = cls;
        while( clazz != null && !clazz.equals(Object.class) ) {
            Field[] fields = clazz.getDeclaredFields();
            
            for( Field f : fields ) {
                int m = f.getModifiers();
            
                if( Modifier.isTransient(m) || Modifier.isStatic(m) ) {
                    continue;
                }
                if (f.getType().getName().equals(Collection.class.getName())) {
                	continue; // this is handled by dependency manager
                }
                if( !f.getType().getName().equals(Translator.class.getName()) ) {
                	targetColumns.add(f.getName());    
                	types.put(f.getName(), f.getType());
                }
            }
            clazz = clazz.getSuperclass();
        }
        
        columns = new String[targetColumns.size()];
        
        for (int i = 0; i < targetColumns.size(); i++) {
        	columns[i] = targetColumns.get(i);
        }        
    }
353311
function(cls,superClass) {
    superClass = lib.resolve.resolve(superClass);
    factory.inherits(cls,superClass);
  }
1254882
public void ensureImport(Class<?> cls) {
        if (currentImports.contains(cls.getName()) == false) {
            newImports.add(cls.getName());
        }
    }
1221411
@Nullable
  private static Object valueOf(String value, Class<?> cls) {
    if (cls == Boolean.TYPE) {
      return Boolean.valueOf(value);
    }
    if (cls == Character.TYPE) {
      return value.length() >= 1 ? value.charAt(0) : defaultValue(char.class);
    }
    if (cls == Byte.TYPE) {
      return Byte.valueOf(value);
    }
    if (cls == Short.TYPE) {
      return Short.valueOf(value);
    }
    if (cls == Integer.TYPE) {
      return Integer.valueOf(value);
    }
    if (cls == Long.TYPE) {
      return Long.valueOf(value);
    }
    if (cls == Float.TYPE) {
      return Float.valueOf(value);
    }
    if (cls == Double.TYPE) {
      return Double.valueOf(value);
    }
    return null;
  }
531210
@SuppressWarnings("unchecked")
    public <T extends XPathBuilder> T setCls(final String cls) {
        this.cls = cls;
        return (T) this;
    }
579875
@Override
    public void visitClassContext(ClassContext clsContext) {
        try {
            stack = new OpcodeStack();
            super.visitClassContext(clsContext);
        } finally {
            stack = null;
        }
    }
762265
public static void removeByC_C_T_ST(long classNameId, long classPK,
		int type, int status) {
		getPersistence().removeByC_C_T_ST(classNameId, classPK, type, status);
	}
1172149
public static String processProtobufType(Class<?> cls) {
        FieldType fieldType = TYPE_MAPPING.get(cls);
        if (fieldType != null) {
            return fieldType.getType();
        }

        return cls.getSimpleName();
    }
252508
public static Method getMethod(Class<?> cls, String methodName, Class<?>... types) {
        try {
            return cls.getMethod(methodName, types);
        } catch (Exception e) {
            return null;
        }
    }
599451
protected void init(Class<T> cls, Key ... keys) {
        readDataSource = Execution.getDataSourceName(cls.getName(), true);
        writeDataSource = Execution.getDataSourceName(cls.getName(), false);
        if( readDataSource == null ) {
            readDataSource = writeDataSource;
        }
        if( writeDataSource == null ) {
            writeDataSource = readDataSource;
        }
        
        if (keys != null && keys.length > 0) {
        	
        	secondaryCache = new ConcurrentHashMap<String,ConcurrentHashMap<String,T>>(keys.length);
        	for (Key k : keys) {
        		secondaryCache.put(k.toString(), new ConcurrentHashMap<String,T>(0));
        	}
        }
    }
292211
public void setSS(java.util.Collection<String> sS) {
        if (sS == null) {
            this.sS = null;
            return;
        }

        this.sS = new java.util.ArrayList<String>(sS);
    }
135683
public void addCounter(String field, Class<? extends Execution> cls) {
        counters.put(field, cls);
    }
1136472
@Override
	public void removeByC_C_T_ST(long classNameId, long classPK, int type,
		int status) {
		for (CPAttachmentFileEntry cpAttachmentFileEntry : findByC_C_T_ST(
				classNameId, classPK, type, status, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(cpAttachmentFileEntry);
		}
	}
930827
function( cls ) {
				var classes = this.getCustomData( 'classes' );
				if ( !this.hasClass( cls ) ) {
					!classes && ( classes = [] ), classes.push( cls );
					this.setCustomData( 'classes', classes );
					this.addClass( cls );
				}
			}