On set comment.

@param cfDef
the cf def
@param cfProperties
the cf properties
@param builder
the builder
339469
private void onSetComment(CfDef cfDef, Properties cfProperties, StringBuilder builder)
    {
        String comment = cfProperties.getProperty(CassandraConstants.COMMENT);
        if (comment != null)
        {
            if (builder != null)
            {
                String comment_Str = CQLTranslator.getKeyword(CassandraConstants.COMMENT);
                builder.append(comment_Str);
                builder.append(CQLTranslator.EQ_CLAUSE);
                builder.append(CQLTranslator.QUOTE_STR);
                builder.append(comment);
                builder.append(CQLTranslator.QUOTE_STR);
                builder.append(CQLTranslator.AND_CLAUSE);

            }
            else
            {
                cfDef.setComment(comment);
            }
        }
    }
388329
@Nonnull
	public static <R> LFltFunction<R> fltFunctionFrom(Consumer<LFltFunctionBuilder<R>> buildingFunction) {
		LFltFunctionBuilder builder = new LFltFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
622328
public static boolean saveProperties(Properties inProperties, File saveFile,
            String comment) {
        try {
            if (!saveFile.exists())
                JMFiles.createEmptyFile(saveFile);
            BufferedWriter writer =
                    new BufferedWriter(new FileWriter(saveFile));
            inProperties.store(writer, comment);
            writer.close();
            return true;
        } catch (IOException e) {
            return JMExceptionManager.handleExceptionAndReturnFalse(log, e,
                    "saveProperties", inProperties, saveFile, comment);
        }

    }
929547
public static CFGBuilder create(@Nonnull MethodDescriptor descriptor, @Nonnull MethodGen methodGen) {
        return new BetterCFGBuilder2(descriptor, methodGen);
    }
1127518
public void setPropertiesField(Field fldProperties)
    {
        if (fldProperties != null)
        {
            m_fldProperties = (PropertiesField)fldProperties;
            this.loadFieldProperties();
            this.addListener(new FileListener(null)
            {
                public void setOwner(ListenerOwner owner)
                {
                    if (owner == null)
                        if (this.getOwner() != null)
                            ((PropertiesInput)PropertiesInput.this).restoreFieldProperties();
                    super.setOwner(owner);
                }
            });
        }
    }
1189560
private function processField(Comment $comment, $property, Entity $entity)
    {
        /** @var \ORMiny\Annotations\Field $fieldAnnotation */
        $fieldAnnotation = current($comment->getAnnotationType(FieldAnnotation::class));

        if ($fieldAnnotation->name === null) {
            $fieldAnnotation->name = $property;
        }

        $field = new Field(
            $this->createSetter($entity, $property, $fieldAnnotation),
            $this->createGetter($entity, $property, $fieldAnnotation)
        );

        $fieldName = $entity->addField($fieldAnnotation->name, $field);

        if ($comment->has('Id')) {
            if ($entity->getPrimaryKey() !== null) {
                throw new EntityDefinitionException("Compound primary key is not supported.");
            }
            $entity->setPrimaryKey($fieldName);
        }
    }
885663
@Override
  public Fact addComment(String comment, Context ctx)
          throws KbTypeException, CreateException {
    return wrapped().addComment(comment, ctx);
  }
802458
protected void initializeEnablementUI(UIBuilder builder) {
      enabled.setEnabled(hasEnablement());
      if (getSelectedProject(builder).hasFacet(CDIFacet_1_1.class))
      {
         priority.setEnabled(hasEnablement());
         builder.add(priority);
      }
      else
      {
         priority.setEnabled(false);
      }
      builder.add(enabled);
   }
130884
public void addClass(ClassDescriptorDef classDef)
    {
        classDef.setOwner(this);
        // Regardless of the format of the class name, we're using the fully qualified format
        // This is safe because of the package & class naming constraints of the Java language
        _classDefs.put(classDef.getQualifiedName(), classDef);
    }
86607
public DescriptionBuilder property(final Consumer<PropertyBuilder> builder) {
        PropertyBuilder propertyBuilder = PropertyBuilder.builder();
        builder.accept(propertyBuilder);
        replaceOrAddProperty(propertyBuilder.build());
        return this;
    }
979622
public void setBuildsDeleted(java.util.Collection<String> buildsDeleted) {
        if (buildsDeleted == null) {
            this.buildsDeleted = null;
            return;
        }

        this.buildsDeleted = new java.util.ArrayList<String>(buildsDeleted);
    }
976907
public void setDefine(final CUtil.StringArrayBuilder defList) throws BuildException {
    if (isReference()) {
      throw tooManyAttributes();
    }
    addDefines(defList.getValue(), true);
  }
229380
@Override
	public void afterPropertiesSet() throws Exception {

		Assert.state(annotation != null, "Annotation type must be configured!");
		Assert.state(linkBuilderFactory != null, "LinkBuilderFactory must be configured!");
		super.afterPropertiesSet();
	}
599657
@Nonnull
	public static LFltIntConsumer fltIntConsumerFrom(Consumer<LFltIntConsumerBuilder> buildingFunction) {
		LFltIntConsumerBuilder builder = new LFltIntConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
808802
private void onSetCompactionThreshold(CfDef cfDef, Properties cfProperties, StringBuilder builder)
    {
        String maxCompactionThreshold = cfProperties.getProperty(CassandraConstants.MAX_COMPACTION_THRESHOLD);
        if (maxCompactionThreshold != null)
        {
            try
            {
                if (builder != null)
                {
                    // Somehow these are not working for cassandra 1.1
                    // though they claim it should work.
                    // appendPropertyToBuilder(builder,
                    // maxCompactionThreshold,
                    // CassandraConstants.MAX_COMPACTION_THRESHOLD);
                }
                else
                {
                    cfDef.setMax_compaction_threshold(Integer.parseInt(maxCompactionThreshold));
                }
            }
            catch (NumberFormatException nfe)
            {
                log.error("Max_Compaction_Threshold should be numeric type, Caused by: .", nfe);
                throw new SchemaGenerationException(nfe);
            }
        }
        String minCompactionThreshold = cfProperties.getProperty(CassandraConstants.MIN_COMPACTION_THRESHOLD);
        if (minCompactionThreshold != null)
        {
            try
            {
                if (builder != null)
                {
                    // Somehow these are not working for cassandra 1.1
                    // though they claim it should work.
                    // appendPropertyToBuilder(builder,
                    // minCompactionThreshold,
                    // CassandraConstants.MIN_COMPACTION_THRESHOLD);
                }
                else
                {
                    cfDef.setMin_compaction_threshold(Integer.parseInt(minCompactionThreshold));
                }
            }
            catch (NumberFormatException nfe)
            {
                log.error("Min_Compaction_Threshold should be numeric type, Caused by: . ", nfe);
                throw new SchemaGenerationException(nfe);
            }
        }
    }
212960
protected void buildField( ClassVisitor cw,
                               FieldDefinition fieldDef) {
        FieldVisitor fv = cw.visitField( Opcodes.ACC_PROTECTED,
                                         fieldDef.getName(),
                                         BuildUtils.getTypeDescriptor( fieldDef.getTypeName() ),
                                         null,
                                         null );


        buildFieldAnnotations( fieldDef, fv );

        fv.visitEnd();
    }
719914
public static void addConstructorArgReference(BeanDefinitionBuilder builder, String beanReference) {
        if (StringUtils.hasText(beanReference)) {
            builder.addConstructorArgReference(beanReference);
        }
    }