Method that generates dynamically the snake-case methods from the available
camelcase properties found inside the bean list.

@param pdl
@throws IntrospectionException
548309
private void add_snake_case_properties(List<PropertyDescriptor> pdl) throws IntrospectionException {
		List<PropertyDescriptor> alternatives = new ArrayList<PropertyDescriptor>();
		for (PropertyDescriptor descriptor : pdl) {
			String camelCase = descriptor.getName();
			if (camelCase.equals("rendererType")) {
				continue;
			}
			if (camelCase.equals("localValueSet")) {
				continue;
			}
			if (camelCase.equals("submittedValue")) {
				continue;
			}
			String snake_case = BsfUtils.camelCaseToSnakeCase(camelCase);
			if (snake_case != camelCase) { // in this particular case, we don't
											// need to use equals!
				if (descriptor.getReadMethod() != null && descriptor.getWriteMethod() != null) {
					String getter = descriptor.getReadMethod().getName();
					String setter = descriptor.getWriteMethod().getName();
					if (UIComponent.class != descriptor.getReadMethod().getDeclaringClass()) {
						PropertyDescriptor alternative = new PropertyDescriptor(snake_case, getDecoratedClass(), getter,
								setter);
						alternative.setBound(true);
						alternatives.add(alternative);

						// more alternatives
						if (camelCase.equals("styleClass")) {
							alternative = new PropertyDescriptor("class", getDecoratedClass(), getter, setter);
							alternative.setBound(true);
							alternatives.add(alternative);
						}
					}
				}

			}
		}
		if (alternatives.size() > 0) {
			pdl.addAll(alternatives);
		}
	}
393582
@Override
    public String[] introspectSelf() {
        List<?> nameValuePairs = Arrays.asList(
                                               BEGIN_TRAN_FOR_SCROLLING_APIS, beginTranForResultSetScrollingAPIs,
                                               BEGIN_TRAN_FOR_VENDOR_APIS, beginTranForVendorAPIs,
                                               COMMIT_OR_ROLLBACK_ON_CLEANUP, commitOrRollbackOnCleanup,
                                               CONNECTION_SHARING, connectionSharing,
                                               DataSourceDef.isolationLevel.name(), isolationLevel,
                                               ResourceFactory.JNDI_NAME, jndiName,
                                               ENABLE_CONNECTION_CASTING, enableConnectionCasting,
                                               QUERY_TIMEOUT, queryTimeout,
                                               STATEMENT_CACHE_SIZE, statementCacheSize,
                                               SUPPLEMENTAL_JDBC_TRACE, supplementalJDBCTrace,
                                               SYNC_QUERY_TIMEOUT_WITH_TRAN_TIMEOUT, syncQueryTimeoutWithTransactionTimeout,
                                               DataSourceDef.transactional.name(), transactional
                                               );
        return new String[] {
                             toString(),
                             nameValuePairs.toString(),
                             PropertyService.hidePasswords(vendorProps).toString() };
    }
737884
private static <L extends Annotation> String defineWhereStatement(final SQLiteModelMethod method, final JQL jql, Class<L> annotation, Map<JQLDynamicStatementType, String> dynamicReplace) {
		StringBuilder builder = new StringBuilder();

		String where = AnnotationUtility.extractAsString(method.getElement(), annotation, AnnotationAttributeType.WHERE);
		if (StringUtils.hasText(where))
			jql.annotatedWhere = true;

		if (StringUtils.hasText(where) || method.hasDynamicWhereConditions()) {
			builder.append(" " + WHERE_KEYWORD);

			if (StringUtils.hasText(where)) {
				jql.staticWhereConditions = true;
				builder.append(StringUtils.startWithSpace(where));
			}

			if (StringUtils.hasText(method.dynamicWhereParameterName)) {
				StringBuilder dynamicBuffer = new StringBuilder();
				dynamicBuffer.append(" #{" + JQLDynamicStatementType.DYNAMIC_WHERE + "}");
				builder.append(" #{" + JQLDynamicStatementType.DYNAMIC_WHERE + "}");

				// define replacement string for WHERE
				dynamicReplace.put(JQLDynamicStatementType.DYNAMIC_WHERE, dynamicBuffer.toString());
			}

		}

		return builder.toString();
	}
419985
public static void generateDynamicPartOfQuery(final SQLiteModelMethod method, MethodSpec.Builder methodBuilder, SplittedSql splittedSql, boolean countQuery) {
		final JQL jql = method.jql;
		if (StringUtils.hasText(splittedSql.sqlGroupStatement)) {
			methodBuilder.addCode("\n// manage GROUP BY statement\n");
			methodBuilder.addStatement("String _sqlGroupByStatement=$S", splittedSql.sqlGroupStatement);
			methodBuilder.addStatement("_sqlBuilder.append($L)", "_sqlGroupByStatement");
		}

		if (StringUtils.hasText(splittedSql.sqlHavingStatement)) {
			methodBuilder.addCode("\n// manage HAVING statement\n");
			methodBuilder.addStatement("String _sqlHavingStatement=$S", splittedSql.sqlHavingStatement);
			methodBuilder.addStatement("_sqlBuilder.append($L)", "_sqlHavingStatement");
		}

		// add order by when the query is not a total count query
		if (countQuery == false) {

			if (jql.isOrderBy()) {
				methodBuilder.addComment("generation order - BEGIN");
				String value = splittedSql.sqlOrderByStatement;
				String valueToReplace = jql.dynamicReplace.get(JQLDynamicStatementType.DYNAMIC_ORDER_BY);

				if (jql.isStaticOrderBy() && !jql.isDynamicOrderBy()) {
					// case static statement and NO dynamic

					methodBuilder.addStatement("String _sqlOrderByStatement=$S", value);
				} else if (jql.isStaticOrderBy() && jql.isDynamicOrderBy()) {
					methodBuilder.addStatement("String _sqlOrderByStatement=$S+$T.ifNotEmptyAppend($L, \", \")", value.replace(valueToReplace, ""), StringUtils.class, "_sortOrder");
				} else if (!jql.isStaticOrderBy() && jql.isDynamicOrderBy()) {
					methodBuilder.addStatement("String _sqlOrderByStatement=$T.ifNotEmptyAppend($L,\" $L \")", StringUtils.class, "_sortOrder", JQLKeywords.ORDER_BY_KEYWORD);
				}

				methodBuilder.addStatement("_sqlBuilder.append($L)", "_sqlOrderByStatement");
				methodBuilder.addComment("generation order - END");
				methodBuilder.addCode("\n");
			}

			if (jql.dynamicReplace.containsKey(JQLDynamicStatementType.DYNAMIC_PAGE_SIZE) || jql.annotatedPageSize) {
				methodBuilder.addComment("generation limit - BEGIN");
				if (SelectBuilderUtility.detectSelectType(method) != SelectType.PAGED_RESULT && !method.isPagedLiveData()) {
					methodBuilder.addStatement("String _sqlLimitStatement=$S", splittedSql.sqlLimitStatement);
				} else if (jql.annotatedPageSize || method.isPagedLiveData()) {
					methodBuilder.addStatement("String _sqlLimitStatement=\" LIMIT \"+$L", "paginatedResult.getPageSize()");
				} else if (jql.hasParamPageSize()) {
					methodBuilder.addStatement("String _sqlLimitStatement=$T.printIf($L>0, \" LIMIT \"+$L)", SqlUtils.class, "paginatedResult.getPageSize()", "paginatedResult.getPageSize()");
				}
				methodBuilder.addStatement("_sqlBuilder.append($L)", "_sqlLimitStatement");
				methodBuilder.addComment("generation limit - END");
				methodBuilder.addCode("\n");
			}

			if (jql.dynamicReplace.containsKey(JQLDynamicStatementType.DYNAMIC_PAGE_OFFSET) && (SelectBuilderUtility.detectSelectType(method) == SelectType.PAGED_RESULT || method.isPagedLiveData())) {
				methodBuilder.addComment("generation offset - BEGIN");
				if (jql.annotatedPageSize || method.isPagedLiveData()) {
					methodBuilder.addStatement("String _sqlOffsetStatement=\" OFFSET \"+paginatedResult.getOffset()", SqlUtils.class);
				} else if (jql.hasParamPageSize()) {
					methodBuilder.addStatement("String _sqlOffsetStatement=$T.printIf($L>0 && paginatedResult.getOffset()>0, \" OFFSET \"+paginatedResult.getOffset())", SqlUtils.class,
							jql.paramPageSize);
				}

				methodBuilder.addStatement("_sqlBuilder.append($L)", "_sqlOffsetStatement");
				methodBuilder.addComment("generation offset - END");
				methodBuilder.addCode("\n");
			}
		}
	}
836329
@Nonnull
	public <V extends T> LObjBiIntPredicateBuilder<T> casesOf(Class<V> argC1, Consumer<LObjBiIntPredicateBuilder<V>> pcpConsumer) {
		PartialCaseWithBoolProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)));

		pc.specifySubCases((Consumer) pcpConsumer);
		return self();
	}
317403
public void generateJavaDoc(MethodSpec.Builder methodBuilder, final SQLiteModelMethod method, TypeName returnType,
			List<SQLProperty> listUsedProperty, ModelProperty primaryKey) {
		// transform JQL to SQL
		String sqlInsert = JQLChecker.getInstance().replace(method, method.jql, new JQLReplacerListenerImpl(method) {

			@Override
			public String onColumnName(String columnName) {
				Set<SQLProperty> property = currentSchema.getPropertyBySimpleName(columnName);

				SQLProperty tempProperty = property.iterator().next();
				AssertKripton.assertTrueOrUnknownPropertyInJQLException(tempProperty != null, method, columnName);

				return tempProperty.columnName;
			}

			@Override
			public String onBindParameter(String bindParameterName, boolean inStatement) {
				String resolvedParamName = method.findParameterNameByAlias(bindParameterName);

				return SqlAnalyzer.PARAM_PREFIX + resolvedParamName + SqlAnalyzer.PARAM_SUFFIX;
			}

		});

		// generate javadoc and result
		{
			String beanNameParameter = method.findParameterAliasByName(method.getParameters().get(0).value0);

			methodBuilder.addJavadoc("<h2>SQL insert</h2>\n");
			methodBuilder.addJavadoc("<pre>$L</pre>\n\n", sqlInsert);
			methodBuilder.addJavadoc(
					"<p><code>$L.$L</code> is automatically updated because it is the primary key</p>\n",
					beanNameParameter, primaryKey.getName());
			methodBuilder.addJavadoc("\n");

			// list of inserted fields
			methodBuilder.addJavadoc("<p><strong>Inserted columns:</strong></p>\n");
			methodBuilder.addJavadoc("<dl>\n");
			for (SQLProperty property : listUsedProperty) {
				methodBuilder.addJavadoc("\t<dt>$L</dt>", property.columnName);
				methodBuilder.addJavadoc("<dd>is mapped to <strong>$L</strong></dd>\n",
						SqlAnalyzer.PARAM_PREFIX + method.findParameterAliasByName(method.getParameters().get(0).value0)
								+ "." + method.findParameterNameByAlias(property.getName()) + SqlAnalyzer.PARAM_SUFFIX);
			}
			methodBuilder.addJavadoc("</dl>\n\n");

			// update bean have only one parameter: the bean to update
			for (Pair<String, TypeName> param : method.getParameters()) {
				methodBuilder.addJavadoc("@param $L", param.value0);
				methodBuilder.addJavadoc("\n\tis mapped to parameter <strong>$L</strong>\n",
						method.findParameterAliasByName(param.value0));
			}

			InsertRawHelper.generateJavaDocReturnType(methodBuilder, returnType);
		}
	}
617393
@Override
    public String[] introspectSelf() {
        String[] debugInfo = new String[6];
        debugInfo[0] = "JSMessageData:";

        // Include the basic toString info so we know who we are
        StringBuilder sb = new StringBuilder("Self: ");
        sb.append(toString());
        debugInfo[1] = new String(sb);

        // Include the cache information
        sb.setLength(0);
        sb.append("Cache: size=");
        sb.append(cacheSize);
        sb.append(" cache=");
        sb.append(cache); // Yes we really do just want [Ljava.lang.Object;@xxxxxx here
        debugInfo[2] = new String(sb);

        // Include the cache information
        sb.setLength(0);
        sb.append("Contents: ");
        if (contents == null) {
            sb.append("null");
        }
        else {
            sb.append("size=");
            sb.append(contents.length);
            sb.append(" contents=");
            sb.append(contents); // Yes we really do just want [B@xxxxxxx here
        }
        debugInfo[3] = new String(sb);

        // Include sharing information
        sb.setLength(0);
        sb.append("Sharing: sharedCache=");
        sb.append(sharedCache);
        sb.append(" sharedContents=");
        sb.append(sharedContents);
        debugInfo[4] = new String(sb);

        // Include all the stuff abot how it fits in to the heirarchy
        sb.setLength(0);
        sb.append("Context: parentMessage=");
        sb.append(parentMessage);
        sb.append(" containingMessage=");
        sb.append(containingMessage);
        sb.append(" master=");
        if (master == this) {
            sb.append("self");
        }
        else {
            sb.append(master);
        }
        sb.append(" compatibilityWrapperOrSelf=");
        if (compatibilityWrapperOrSelf == this) {
            sb.append("self");
        }
        else {
            sb.append(compatibilityWrapperOrSelf);
        }
        debugInfo[5] = new String(sb);

        // Now return it all
        return debugInfo;
    }
1168405
public static void introspect(IntrospectionWriter writer)
    {
        writer.begin("Container Properties");
        writer.println("Property: AllowCachedTimerDataFor = " + AllowCachedTimerDataFor);//F001419
        writer.println("Property: AllowCustomFinderSQLForUpdate = " + AllowCustomFinderSQLForUpdate);
        writer.println("Property: AllowEarlyInsert        = " + AllowEarlyInsert);
        writer.println("Property: AllowPrimaryKeyMutation = " + AllowPrimaryKeyMutation);
        writer.println("Property: AllowSpecViolationOnRollback = " + AllowSpecViolationOnRollback); //PK87857
        writer.println("Property: AsyncResultNoResponseBackoff = " + AsyncNoResponseBackoff);
        writer.println("Property: BindToJavaGlobal        = " + BindToJavaGlobal);
        writer.println("Property: BindToServerRoot        = " + BindToServerRoot);
        writer.println("Property: BlockWorkUntilAppStarted = " + BlockWorkUntilAppStarted); // F743-15941
        writer.println("Property: BlockWorkUntilAppStartedWaitTime = " + BlockWorkUntilAppStartedWaitTime); // F743-15941
        writer.println("Property: CheckAppConfig          = " + CheckAppConfig); // F743-13921
        writer.println("Property: CreateInstanceAtStart   = " + CreateInstanceAtStart);
        writer.println("Property: DefaultSessionAccessTimeout = " + DefaultSessionAccessTimeout); // d704504
        writer.println("Property: DefaultStatefulSessionTimeout  = " + DefaultStatefulSessionTimeout); // F743-14726  d627044
        writer.println("Property: DisableAsyncMethods     = " + DisableAsyncMethods); // F743-13022
        writer.println("Property: DisableAsyncResultRetries = " + DisableAsyncResultRetries);
        writer.println("Property: DisableAutomaticLightweightMethods = " + DisableAutomaticLightweightMethods);
        writer.println("Property: DisableMDBs             = " + DisableMDBs); // F743-13023
        writer.println("Property: DisableRemote           = " + DisableRemote); // F743-13024.CdRv
        writer.println("Property: DisableShortDefaultBindings = " + DisableShortDefaultBindings);
        writer.println("Property: DisableTimers           = " + DisableTimers); // F743-13022
        writer.println("Property: DisablePersistentTimers = " + DisablePersistentTimers); // PI50798
        writer.println("Property: EE5Compatibility        = " + EE5Compatibility); // F743-14982CdRv
        writer.println("Property: EE6Compatibility        = " + EE6Compatibility); // RTC113949
        writer.println("Property: EmptyAnnotationIgnoresExplicitInterfaces = " +
                       EmptyAnnotationIgnoresExplicitInterfaces); // RTC113949
        writer.println("Property: ExcludeNestedExceptions = " + ExcludeNestedExceptions); // d672063
        writer.println("Property: ExpandCMPCFJNDIName     = " + ExpandCMPCFJNDIName); //d425164
        writer.println("Property: FbpkAlwaysReadOnly      = " + FbpkAlwaysReadOnly);
        writer.println("Property: IgnoreDuplicateEJBBindings = " + IgnoreDuplicateEJBBindings);
        writer.println("Property: IncludeNestedExceptions = " + IncludeNestedExceptions);
        writer.println("Property: IncludeNestedExceptionsExtended = " + IncludeNestedExceptionsExtended); //PK87857
        writer.println("Property: IndirectLocalProxies    = " + IndirectLocalProxies);
        writer.println("Property: InitializeEJBsAtStartup = " + InitializeEJBsAtStartup);
        writer.println("Property: MaxAsyncResultWaitTime  = " + MaxAsyncResultWaitTime);
        writer.println("Property: MaxUnclaimedAsyncResults = " + MaxUnclaimedAsyncResults); // d690014.1
        writer.println("Property: NoEJBPool               = " + NoEJBPool);
        writer.println("Property: NoPrimaryKeyMutation    = " + NoPrimaryKeyMutation);
        writer.println("Property: PassivationPolicy       = " + PassivationPolicy);
        writer.println("Property: PersistentTimerSingletonDeadlockTimeout = " + PersistentTimerSingletonDeadlockTimeout);
        writer.println("Property: PoolSize                = " + PoolSize);
        writer.println("Property: Portable                = " + Portable);
        writer.println("Property: PortableFinder          = " + PortableFinder);
        writer.println("Property: RMICCompatible          = " + RMICCompatible);
        writer.println("Property: StrictMaxCacheSize      = " + StrictMaxCacheSize);
        writer.println("Property: TimerCancelTimeout      = " + TimerCancelTimeout);
        writer.println("Property: TimerQOSAtLeastOnceForRequired = " + TimerQOSAtLeastOnceForRequired);
        writer.println("Property: ThrowRemoteFromEjb3Stub = " + ThrowRemoteFromEjb3Stub);
        writer.println("Property: UseFairSingletonLockingPolicy = " + UseFairSingletonLockingPolicy); // F743-9002
        writer.println("Property: UserInstallRoot         = " + UserInstallRoot);
        writer.println("Property: WLMAllowOptionAReadOnly = " + WLMAllowOptionAReadOnly);
        writer.println("Property: ExtendSetRollbackOnlyBehaviorBeyondInstanceFor = " +
                       ExtendSetRollbackOnlyBehaviorBeyondInstanceFor);
        writer.println("Property: LimitSetRollbackOnlyBehaviorToInstanceFor = " +
                       LimitSetRollbackOnlyBehaviorToInstanceFor);
        writer.end();
    }
563876
protected
  void introspect() {
    try {
      BeanInfo bi = Introspector.getBeanInfo(obj.getClass());
      props = bi.getPropertyDescriptors();
    } catch (IntrospectionException ex) {
      LogLog.error("Failed to introspect "+obj+": " + ex.getMessage());
      props = new PropertyDescriptor[0];
    }
  }
1193923
private static <T> int setStatementParameters(final T item,
                                                 final Introspected introspected,
                                                 final FieldColumnInfo[] fcInfos,
                                                 final PreparedStatement stmt,
                                                 final int[] parameterTypes,
                                                 final Set<String> excludedColumns) throws SQLException
   {
      int parameterIndex = 1;
      for (final FieldColumnInfo fcInfo : fcInfos) {
         if (excludedColumns == null || !isIgnoredColumn(excludedColumns, fcInfo.getColumnName())) {
            final int parameterType = parameterTypes[parameterIndex - 1];
            final Object object = mapSqlType(introspected.get(item, fcInfo), parameterType);
            if (object != null && !fcInfo.isSelfJoinField()) {
               stmt.setObject(parameterIndex, object, parameterType);
            }
            else {
               stmt.setNull(parameterIndex, parameterType);
            }
            ++parameterIndex;
         }
      }
      return parameterIndex;
   }
834997
private static JQL buildJQLUpdate(final SQLiteModelMethod method, final JQL result, final Map<JQLDynamicStatementType, String> dynamicReplace, String preparedJql) {
		final Class<? extends Annotation> annotation = BindSqlUpdate.class;

		// extract some informaction from method and bean
		// use annotation's attribute value and exclude and bean definition to
		// define field list
		// final Set<String> fields = defineFields(JQLType.UPDATE, method,
		// annotation, false);

		if (StringUtils.hasText(preparedJql)) {
			result.value = preparedJql;
			// UPDATE can contains bind parameter in column values and select
			// statement
			final One<Boolean> inWhereCondition = new One<Boolean>(false);
			final One<Boolean> inColumnsToUpdate = new One<Boolean>(false);

			JQLChecker.getInstance().analyze(method, result, new JqlBaseListener() {

				@Override
				public void enterProjected_columns(Projected_columnsContext ctx) {
					if (inColumnsToUpdate.value0) {
						result.containsSelectOperation = true;
					}

				}

				@Override
				public void enterConflict_algorithm(Conflict_algorithmContext ctx) {
					result.conflictAlgorithmType = ConflictAlgorithmType.valueOf(ctx.getText().toUpperCase());
				}

				@Override
				public void enterWhere_stmt(Where_stmtContext ctx) {
					inWhereCondition.value0 = true;
				}

				@Override
				public void exitWhere_stmt_clauses(Where_stmt_clausesContext ctx) {
					inWhereCondition.value0 = false;
				}

				@Override
				public void enterBind_parameter(Bind_parameterContext ctx) {
					if (inWhereCondition.value0) {
						result.bindParameterOnWhereStatementCounter++;
					} else {
						result.bindParameterAsColumnValueCounter++;
					}
				}

				@Override
				public void enterBind_dynamic_sql(Bind_dynamic_sqlContext ctx) {
					JQLDynamicStatementType dynamicType = JQLDynamicStatementType.valueOf(ctx.bind_parameter_name().getText().toUpperCase());

					int start = ctx.getStart().getStartIndex() - 1;
					int stop = ctx.getStop().getStopIndex() + 1;

					String dynamicWhere = result.value.substring(start, stop);

					dynamicReplace.put(dynamicType, dynamicWhere);

					// super.enterBind_dynamic_sql(ctx);
				}

				@Override
				public void enterColumns_to_update(Columns_to_updateContext ctx) {
					inColumnsToUpdate.value0 = true;
				}

				@Override
				public void exitColumns_to_update(Columns_to_updateContext ctx) {
					inColumnsToUpdate.value0 = false;
				}

			});

			JQLChecker.getInstance().replaceVariableStatements(method, preparedJql, new JQLReplaceVariableStatementListenerImpl() {

				@Override
				public String onWhere(String statement) {
					result.annotatedWhere = true;
					result.staticWhereConditions = true;
					return null;
				}

			});

			if (result.containsSelectOperation) {
				AssertKripton.assertTrueOrInvalidMethodSignException(method.getReturnClass().equals(TypeName.VOID), method, "defined JQL requires that method's return type is void");
			}
		} else {
			final SQLiteDaoDefinition dao = method.getParent();
			Set<String> fields;
			ModifyType modifyType = SqlModifyBuilder.detectModifyType(method, JQLType.UPDATE);
			if (modifyType == ModifyType.UPDATE_BEAN) {
				fields = extractFieldsFromAnnotation(method, annotation, false);
			} else {
				fields = extractFieldsFromMethodParameters(method, annotation);
			}

			AssertKripton.assertTrueOrInvalidMethodSignException(fields.size() > 0, method, "no field was specified for update");

			result.conflictAlgorithmType = ConflictAlgorithmType.valueOf(AnnotationUtility.extractAsEnumerationValue(method.getElement(), annotation, AnnotationAttributeType.CONFLICT_ALGORITHM_TYPE));

			StringBuilder builder = new StringBuilder();
			builder.append(UPDATE_KEYWORD);
			builder.append(" " + result.conflictAlgorithmType.getSqlForInsert());
			// entity name
			builder.append(dao.getEntitySimplyClassName());

			// recreate fields
			final One<String> prefix = new One<>("");
			if (result.hasParamBean()) {
				prefix.value0 = result.paramBean + ".";
			}

			builder.append(" " + SET_KEYWORD + " ");

			builder.append(forEachFields(fields, new OnFieldListener() {

				@Override
				public String onField(String item) {
					return item + "=" + SqlAnalyzer.PARAM_PREFIX + prefix.value0 + item + SqlAnalyzer.PARAM_SUFFIX;
				}
			}));

			builder.append(defineWhereStatement(method, result, annotation, dynamicReplace));

			result.value = builder.toString();
		}
		result.operationType = JQLType.UPDATE;
		result.dynamicReplace = dynamicReplace;
		return result;
	}
233756
@Override
	public SExpIR caseABooleanConstExp(ABooleanConstExp node, IRInfo question)
			throws AnalysisException
	{
		PType type = node.getType();
		boolean value = node.getValue().getValue();

		STypeIR typeCg = type.apply(question.getTypeVisitor(), question);

		ABoolLiteralExpIR boolLitCg = new ABoolLiteralExpIR();
		boolLitCg.setType(typeCg);
		boolLitCg.setValue(value);

		return boolLitCg;
	}
461951
@Override
    public void introspect(PrintWriter writer) {
        RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();

        introspectUptime(runtime, writer);
        introspectVendorVersion(runtime, writer);
        introspectInputArguments(runtime, writer);
        Map<String, String> props = introspectSystemProperties(runtime, writer);
        //introspectPaths(runtime, writer);
        introspectDirsFromSystemProperties(runtime, writer, "java.ext.dirs", props);
        introspectDirsFromSystemProperties(runtime, writer, "java.endorsed.dirs", props);
    }
849711
protected void addSingleUpsertToSqlMap(Document document, IntrospectedTable introspectedTable) {
    XmlElement update = new XmlElement("update");
    update.addAttribute(new Attribute("id", UPSERT));
    update.addAttribute(new Attribute("parameterType", "map"));

    generateSqlMapContent(introspectedTable, update);

    document.getRootElement().addElement(update);
  }
103788
private VariableDeclaration generateClassForSoyElement(
      String soyElementClassName, String soyElementAccessorName, TemplateElementNode node) {

    String paramsType = node.getParams().isEmpty() ? "null" : "!" + alias + ".Params";
    String optIjDataType = "!soy.IjData=";

    ImmutableList.Builder<MethodDeclaration> stateMethods = ImmutableList.builder();
    for (TemplateStateVar stateVar : node.getStateVars()) {
      stateMethods.addAll(
          this.generateStateMethodsForSoyElementClass(soyElementClassName, stateVar));
    }
    ImmutableList.Builder<MethodDeclaration> parameterMethods = ImmutableList.builder();
    for (TemplateParam param : node.getParams()) {
      parameterMethods.add(this.generateGetParamMethodForSoyElementClass(param, false));
    }

    ImmutableList.Builder<Statement> stateVarInitializations = ImmutableList.builder();
    for (TemplateStateVar stateVar : node.getStateVars()) {
      JsType jsType = JsType.forIncrementalDomState(stateVar.type());
      JsDoc stateVarJsdoc =
          JsDoc.builder().addParameterizedAnnotation("private", jsType.typeExpr()).build();
      stateVarInitializations.add(
          Statement.assign(
              Expression.THIS.dotAccess(STATE_PREFIX + stateVar.name()),
              translateExpr(stateVar.defaultValue()),
              stateVarJsdoc));
    }
    // Build constructor method.
    Statement ctorBody =
        Statement.of(
            id("super").call(JsRuntime.OPT_DATA, JsRuntime.OPT_IJ_DATA).asStatement(),
            Statement.of(stateVarInitializations.build()));
    MethodDeclaration constructorMethod =
        MethodDeclaration.create(
            "constructor",
            JsDoc.builder()
                .addParam("opt_data", paramsType)
                .addParam("opt_ijData", optIjDataType)
                .build(),
            ctorBody);

    Statement maybeRender =
        Statement.ifStatement(
                id("super")
                    .dotAccess("renderInternal")
                    .call(INCREMENTAL_DOM, JsRuntime.OPT_DATA, id("ignoreSkipHandler")),
                Statement.returnValue(Expression.LITERAL_TRUE))
            .build();

    // Build `renderInternal` method.
    MethodDeclaration renderInternalMethod =
        MethodDeclaration.create(
            "renderInternal",
            JsDoc.builder()
                .addParam(INCREMENTAL_DOM_PARAM_NAME, "!incrementaldomlib.IncrementalDomRenderer")
                .addParam("opt_data", paramsType)
                .addParam("ignoreSkipHandler", "boolean=")
                .addAnnotation("protected")
                .addAnnotation("override")
                .addParameterizedAnnotation("suppress", "checkTypes")
                .build(),
            Statement.of(
                maybeRender,
                // Various parts of the js codegen expects these parameters to be in the local
                // scope.
                VariableDeclaration.builder("opt_ijData")
                    .setRhs(Expression.THIS.dotAccess("ijData"))
                    .build(),
                generateIncrementalDomRenderCalls(node, alias),
                Statement.returnValue(Expression.LITERAL_FALSE)));

    ClassExpression soyElementClass =
        ClassExpression.create(
            SOY_IDOM.dotAccess("$SoyElement"),
            ImmutableList.<MethodDeclaration>builder()
                .add(constructorMethod, renderInternalMethod)
                .addAll(stateMethods.build())
                .addAll(parameterMethods.build())
                .build());
    String elementAccessor = soyElementClassName + "Interface";
    VariableDeclaration classExpression =
        VariableDeclaration.builder(soyElementClassName)
            .setJsDoc(
                JsDoc.builder()
                    .addAnnotation(
                        "extends",
                        "{soyIdom.$SoyElement<" + paramsType + ",!" + elementAccessor + ">}")
                    .addParameterizedAnnotation("implements", soyElementAccessorName)
                    .build())
            .setRhs(soyElementClass)
            .build();
    return classExpression;
  }
171808
private List<PropertyDescriptor> getPropertyDescriptorsForClass(Class<?> clasz) {
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(clasz);
            return Arrays.asList(beanInfo.getPropertyDescriptors());
        } catch (IntrospectionException e) {
            LOGGER.error("instantiation exception while trying to create instance of class {}", clasz.getName());
        }
        return Lists.newArrayList();
    }
143648
@Trivial
    public final Map<String, String> getExecutionProperties() {
        TreeMap<String, String> copy = null;
        if (internalPropNames != null) {
            copy = new TreeMap<String, String>(threadContextDescriptor.getExecutionProperties());
            for (String name : internalPropNames)
                copy.remove(name);
        }
        return copy;
    }