usually a single line of:<br>
#=GC &lt;feature&gt; &lt;Generic per-Column annotation, exactly 1 char per column&gt;

@param featureName
the feature name :)
@param value
the line to be parsed.
165787
private void handleConsensusAnnotation(String featureName, String value) {
		if (featureName.equals(GC_SECONDARY_STRUCTURE)) {
			stockholmStructure.getConsAnnotation().setSecondaryStructure(value);
		} else if (featureName.equals(GC_SEQUENSE_CONSENSUS)) {
			stockholmStructure.getConsAnnotation().setSequenceConsensus(value);
		} else if (featureName.equals(GC_SURFACE_ACCESSIBILITY)) {
			stockholmStructure.getConsAnnotation().setSurfaceAccessibility(value);
		} else if (featureName.equals(GC_TRANS_MEMBRANE)) {
			stockholmStructure.getConsAnnotation().setTransMembrane(value);
		} else if (featureName.equals(GC_POSTERIOR_PROBABILITY)) {
			stockholmStructure.getConsAnnotation().setPosteriorProbability(value);
		} else if (featureName.equals(GC_LIGAND_BINDING)) {
			stockholmStructure.getConsAnnotation().setLigandBinding(value);
		} else if (featureName.equals(GC_ACTIVE_SITE)) {
			stockholmStructure.getConsAnnotation().setActiveSite(value);
		} else if (featureName.equals(GC_AS_PFAM_PREDICTED)) {
			stockholmStructure.getConsAnnotation().setAsPFamPredicted(value);
		} else if (featureName.equals(GC_AS_SWISSPROT)) {
			stockholmStructure.getConsAnnotation().setAsSwissProt(value);
		} else if (featureName.equals(GC_INTRON)) {
			stockholmStructure.getConsAnnotation().setIntron(value);
		} else if (featureName.equals(GC_REFERENCE_ANNOTATION)) {
			stockholmStructure.getConsAnnotation().setReferenceAnnotation(value);
		} else if (featureName.equals(GC_MODEL_MASK)) {
			stockholmStructure.getConsAnnotation().setModelMask(value);
		} else {
			// unknown feature
			logger.warn("Unknown Consensus Feature [{}].\nPlease contact the Biojava team.", featureName);
		}
	}
42519
public void report(FeatureEnum name, EPUBLocation location, String value)
  {
    features.put(name, new Feature(name, location, value));
  }
989148
function(feature) {
        if (!feature) return null;

        var featureName = feature.eClass ? feature.get('name') : feature;

        if (!_.has(this.values, featureName) && this.has(featureName)) {
            initValue(this, getEStructuralFeature(this.eClass, featureName));
        }

        var value = this.values[featureName];

        if (typeof value === 'function') {
            return value.apply(this);
        } else {
            return value;
        }
    }
1023700
public static Expression constant(final char value) {
    return new Expression(Type.CHAR_TYPE, Feature.CHEAP) {
      @Override
      protected void doGen(CodeBuilder mv) {
        mv.pushInt(value);
      }
    };
  }
1339673
public void visit(final String name, final Object value) {
        ++size;
        if (named) {
            bv.putShort(cw.newUTF8(name));
        }
        if (value instanceof String) {
            bv.put12('s', cw.newUTF8((String) value));
        } else if (value instanceof Byte) {
            bv.put12('B', cw.newInteger(((Byte) value).byteValue()).index);
        } else if (value instanceof Boolean) {
            int v = ((Boolean) value).booleanValue() ? 1 : 0;
            bv.put12('Z', cw.newInteger(v).index);
        } else if (value instanceof Character) {
            bv.put12('C', cw.newInteger(((Character) value).charValue()).index);
        } else if (value instanceof Short) {
            bv.put12('S', cw.newInteger(((Short) value).shortValue()).index);
        } else if (value instanceof Type) {
            bv.put12('c', cw.newUTF8(((Type) value).getDescriptor()));
        } else if (value instanceof byte[]) {
            byte[] v = (byte[]) value;
            bv.put12('[', v.length);
            for (int i = 0; i < v.length; i++) {
                bv.put12('B', cw.newInteger(v[i]).index);
            }
        } else if (value instanceof boolean[]) {
            boolean[] v = (boolean[]) value;
            bv.put12('[', v.length);
            for (int i = 0; i < v.length; i++) {
                bv.put12('Z', cw.newInteger(v[i] ? 1 : 0).index);
            }
        } else if (value instanceof short[]) {
            short[] v = (short[]) value;
            bv.put12('[', v.length);
            for (int i = 0; i < v.length; i++) {
                bv.put12('S', cw.newInteger(v[i]).index);
            }
        } else if (value instanceof char[]) {
            char[] v = (char[]) value;
            bv.put12('[', v.length);
            for (int i = 0; i < v.length; i++) {
                bv.put12('C', cw.newInteger(v[i]).index);
            }
        } else if (value instanceof int[]) {
            int[] v = (int[]) value;
            bv.put12('[', v.length);
            for (int i = 0; i < v.length; i++) {
                bv.put12('I', cw.newInteger(v[i]).index);
            }
        } else if (value instanceof long[]) {
            long[] v = (long[]) value;
            bv.put12('[', v.length);
            for (int i = 0; i < v.length; i++) {
                bv.put12('J', cw.newLong(v[i]).index);
            }
        } else if (value instanceof float[]) {
            float[] v = (float[]) value;
            bv.put12('[', v.length);
            for (int i = 0; i < v.length; i++) {
                bv.put12('F', cw.newFloat(v[i]).index);
            }
        } else if (value instanceof double[]) {
            double[] v = (double[]) value;
            bv.put12('[', v.length);
            for (int i = 0; i < v.length; i++) {
                bv.put12('D', cw.newDouble(v[i]).index);
            }
        } else {
            Item i = cw.newConstItem(value);
            bv.put12(".s.IFJDCS".charAt(i.type), i.index);
        }
    }

    public void visitEnum(
        final String name,
        final String desc,
        final String value)
    {
        ++size;
        if (named) {
            bv.putShort(cw.newUTF8(name));
        }
        bv.put12('e', cw.newUTF8(desc)).putShort(cw.newUTF8(value));
    }

    public AnnotationVisitor visitAnnotation(
        final String name,
        final String desc)
    {
        ++size;
        if (named) {
            bv.putShort(cw.newUTF8(name));
        }
        // write tag and type, and reserve space for values count
        bv.put12('@', cw.newUTF8(desc)).putShort(0);
        return new AnnotationWriter(cw, true, bv, bv, bv.length - 2);
    }

    public AnnotationVisitor visitArray(final String name) {
        ++size;
        if (named) {
            bv.putShort(cw.newUTF8(name));
        }
        // write tag, and reserve space for array size
        bv.put12('[', 0);
        return new AnnotationWriter(cw, false, bv, bv, bv.length - 2);
    }

    public void visitEnd() {
        if (parent != null) {
            byte[] data = parent.data;
            data[offset] = (byte) (size >>> 8);
            data[offset + 1] = (byte) size;
        }
    }
834257
private void validateRangeValue(String column, Object value) {
		if (constraintType != null && value != null
				&& !getConstraintType().equals(DataColumnConstraintType.RANGE)) {
			throw new GeoPackageException("The " + column
					+ " must be null for " + DataColumnConstraintType.ENUM
					+ " and " + DataColumnConstraintType.GLOB + " constraints");
		}
	}
928853
@NonNull
  public SimpleStatementBuilder addNamedValue(@NonNull String name, @Nullable Object value) {
    return addNamedValue(CqlIdentifier.fromCql(name), value);
  }
747915
def normalizeFeatureText(value):
    
    if not isinstance(value, basestring):
        raise TypeError("Feature text must be a string, not %s."
                        % type(value).__name__)
    return unicode(value)
1313335
@Override
   public void groupingValue(String collateName) {
      // collationName is ignored for now
      if (groupBy == null) {
         groupBy = new ArrayList<>(ARRAY_INITIAL_LENGTH);
      }
      groupBy.add(resolveAlias(propertyPath));
   }
616832
static void accept(final AnnotationVisitor av, final String name,
            final Object value) {
        if (av != null) {
            if (value instanceof String[]) {
                String[] typeconst = (String[]) value;
                av.visitEnum(name, typeconst[0], typeconst[1]);
            } else if (value instanceof AnnotationNode) {
                AnnotationNode an = (AnnotationNode) value;
                an.accept(av.visitAnnotation(name, an.desc));
            } else if (value instanceof List) {
                AnnotationVisitor v = av.visitArray(name);
                List<?> array = (List<?>) value;
                for (int j = 0; j < array.size(); ++j) {
                    accept(v, null, array.get(j));
                }
                v.visitEnd();
            } else {
                av.visit(name, value);
            }
        }
    }
1165015
public int getIndex(String feature)
	{
		//logger.debug("FeatureIndex.get : " + feature + "(" + count + ")");
		Integer index = (Integer) map.get(feature);

		if (index == null)
			return -1;

		return index.intValue();
	}
856163
public void setDouble(String fieldName, Double value) {
		if (value == null) {
			throw new IllegalArgumentException("参数值[" + fieldName + "]不能为NULL.");
		}
		fieldList.add(fieldName);
		statementParameter.setDouble(value);
	}
1328886
private void setTag(final int i, final String name, final String value, 
      final boolean groupby) {
    setTagName(i, name);
    setTagValue(i, value);
    isTagGroupby(i, groupby);
  }
1054834
@Override
    public ProvisioningFeatureDefinition getFeature(String featureName) {
        ProvisioningFeatureDefinition result = repo.getFeature(featureName);
        if (result == null) {
            return null;
        }
        if (restricted.contains(result.getSymbolicName())) {
            // record the restricted attemp
            if (!restrictedAttempts.contains(result.getSymbolicName())) {
                restrictedAttempts.add(result.getSymbolicName());
            }
            return null;
        }
        return result;
    }
1024832
private String readExtensions(final String featureName) {
        final Set<String> exts = new HashSet<>();
        if (featureTable.containsKey(featureName)) {
            for (final Value ext : featureTable.get(featureName)) {
                final String e = ext.value.trim();
                if (e.length() != 0) {
                    exts.add(e);
                }
            }
        }
        return StringUtils.join(exts, CONF_LIST_SEPARATOR);
    }
498908
private static void validateCsvFormat(CharSequence value) {
        int length = value.length();
        for (int i = 0; i < length; i++) {
            switch (value.charAt(i)) {
                case DOUBLE_QUOTE:
                case LINE_FEED:
                case CARRIAGE_RETURN:
                case COMMA:
                    // If value contains any special character, it should be enclosed with double-quotes
                    throw newInvalidEscapedCsvFieldException(value, i);
                default:
            }
        }
    }
726868
public final void setCorrelationId(String value) {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setCorrelationId", value);
        /* If the String starts with ID_STRING we have to chack it is valid, and */
        /* convert it to lower-case before storing it. */
        if ((value != null) && (value.startsWith(ID_STRING))) {
            boolean needsConvert = false;
            int length = value.length();
            char ch;

            /* Including the ID: it must have an odd number of characters */
            if ((length % 2) == 0) {
                String nlsMsg = nls.getFormattedMessage("BAD_HEX_STRING_CWSIF0191"
                                                        , new Object[] { value }
                                                        , "The hexadecimal string " + value + " is incorrectly formatted for a Correlation Id"
                                );

                IllegalArgumentException e = new IllegalArgumentException(nlsMsg);
                if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                    SibTr.exit(this, tc, "setCorrelationId", e);
                throw e;
            }

            /* Check each character is valid and for upper-case */
            for (int i = 3; i < length; i++) {
                ch = value.charAt(i);
                if (Character.digit(ch, 16) < 0) {
                    String nlsMsg = nls.getFormattedMessage("BAD_HEX_STRING_CWSIF0191"
                                                            , new Object[] { value }
                                                            , "The hexadecimal string " + value + " is incorrectly formatted for a Correlation Id"
                                    );
                    IllegalArgumentException e = new IllegalArgumentException(nlsMsg);
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(this, tc, "setCorrelationId", e);
                    throw e;
                }
                if (Character.isUpperCase(ch))
                    needsConvert = true;
            }

            /* Convert if necessary */
            if (needsConvert) {
                value = ID_STRING + value.substring(3).toLowerCase();
            }

        }

        if (value != null) {
            /* If we got to here, we have a the String and it must be OK */
            getApi().setField(JsApiAccess.CORRELATIONID_STRINGVALUE, value);
        }
        else {
            /* otherwise set the variant to empty */
            getApi().setChoiceField(JsApiAccess.CORRELATIONID, JsApiAccess.IS_CORRELATIONID_EMPTY);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setCorrelationId");
    }