http://ocrsdk.com/documentation/apireference/processTextField/
164205
def process_text_field(image_path, options = {})
      RestClient.post("#{url}/processTextField", options.merge(:upload => { :file => File.new(image_path, 'r') }))
    end
876354
@SuppressWarnings({ "rawtypes", "unchecked" }) // Using correct types, but wildcards fail to see that.
    private void processFields(final Object component, final Field[] fields, final Context context,
            final ContextDestroyer contextDestroyer) {
        for (final Field field : fields) {
            final com.badlogic.gdx.utils.reflect.Annotation[] annotations = getAnnotations(field);
            if (annotations == null || annotations.length == 0) {
                continue;
            }
            for (final com.badlogic.gdx.utils.reflect.Annotation annotation : annotations) {
                if (fieldProcessors.containsKey(annotation.getAnnotationType())) {
                    for (final AnnotationProcessor processor : fieldProcessors.get(annotation.getAnnotationType())) {
                        processor.processField(field, annotation.getAnnotation(annotation.getAnnotationType()),
                                component, context, this, contextDestroyer);
                    }
                }
            }
        }
    }
1081437
function processTextNode(node, options) {
    options = options || {};

    var data = [].concat(getBasicFields(node, options)).
        concat([
            node.lineCount
        ]);

    if (!options.body) {
        data = data.concat(getExtensionFields(node, options));
    }

    data.node = node;
    return data;
}
72522
public void fieldToData(ComponentCache componentCache, int iRowIndex, int iColumnIndex)
    {
        if (componentCache.m_rgcompoments[iColumnIndex] != null)
        {
            Object object = this.getModel().getValueAt(iRowIndex, iColumnIndex);
            String string = "";
            if (object != null)
                string = object.toString();
            if (componentCache.m_rgcompoments[iColumnIndex] instanceof JTextComponent)
                ((JTextComponent)componentCache.m_rgcompoments[iColumnIndex]).setText(string);
            else if (componentCache.m_rgcompoments[iColumnIndex] instanceof JCheckBox)
            {
                boolean bIsSelected = false;
                if (string != null) if (string.equals("1"))
                    bIsSelected = true;
                ((JCheckBox)componentCache.m_rgcompoments[iColumnIndex]).setSelected(bIsSelected);
            }
        }
    }
1109273
private void processParameters() throws BadElementException, IOException {
        type = IMGTEMPLATE;
        originalType = ORIGINAL_WMF;
        InputStream is = null;
        try {
            String errorID;
            if (rawData == null){
                is = url.openStream();
                errorID = url.toString();
            }
            else{
                is = new java.io.ByteArrayInputStream(rawData);
                errorID = "Byte array";
            }
            InputMeta in = new InputMeta(is);
            if (in.readInt() != 0x9AC6CDD7)	{
                throw new BadElementException(errorID + " is not a valid placeable windows metafile.");
            }
            in.readWord();
            int left = in.readShort();
            int top = in.readShort();
            int right = in.readShort();
            int bottom = in.readShort();
            int inch = in.readWord();
            dpiX = 72;
            dpiY = 72;
            scaledHeight = (float)(bottom - top) / inch * 72f;
            setTop(scaledHeight);
            scaledWidth = (float)(right - left) / inch * 72f;
            setRight(scaledWidth);
        }
        finally {
            if (is != null) {
                is.close();
            }
            plainWidth = getWidth();
            plainHeight = getHeight();
        }
    }
1193501
def process_fields_param(fields):
    
    if not fields:
        return fields
    if isinstance(fields, six.string_types):
        fields = split_strip(fields)
    if '_type' not in fields:
        fields.append('_type')
    return {
        '_source_include': fields,
        '_source': True,
    }
842703
private void processFields() throws CoreException {

        final Class<?> currentClass = this.getClass();

        // Parse view properties
        for (final Field f : currentClass.getDeclaredFields()) {

            // Only Node and Animation properties are eligible
            if (Node.class.isAssignableFrom(f.getType()) || Animation.class.isAssignableFrom(f.getType())) {

                // If a property was private, it must set to accessible = false after processing action
                boolean needToHide = false;
                // For private properties, set them accessible temporary
                if (!f.isAccessible()) {
                    f.setAccessible(true);
                    needToHide = true;
                }

                // Process all existing annotation for the current field
                processAnnotations(f);

                // Reset the property visibility
                if (needToHide && f.isAccessible()) {
                    f.setAccessible(false);
                }
            }
        }
    }
403826
public CAS process(String text) {
        CAS cas = retrieve();
        if (cas == null)
            return null;

        cas.setDocumentText(text);
        try {
            analysisEngine.process(cas);
        } catch (AnalysisEngineProcessException e) {
            log.warn("Unable to process text " + text, e);
        }

        return cas;


    }
919910
protected FieldMetadata processSimpleType( FieldDeclaration fieldDeclaration ) {
        SimpleType simpleType = (SimpleType)fieldDeclaration.getType();
        FieldMetadata simpleTypeFieldMetadata = FieldMetadata.simpleType(JavaMetadataUtil.getName(simpleType.getName()));
        // modifiers
        processModifiersOfFieldDeclaration(fieldDeclaration, simpleTypeFieldMetadata);
        processVariablesOfVariableDeclarationFragment(fieldDeclaration, simpleTypeFieldMetadata);
        simpleTypeFieldMetadata.setName(getFieldName(fieldDeclaration));

        return simpleTypeFieldMetadata;
    }
287692
private void processTextNode(Segment textSegment) {
    context.setCurrentSegment(textSegment);
    String elementText = textSegment.toString();

    Matcher matcher = VUE_MUSTACHE_PATTERN.matcher(elementText);

    int lastEnd = 0;
    StringBuilder newText = new StringBuilder();
    while (matcher.find()) {
      int start = matcher.start();
      int end = matcher.end();
      if (start > 0) {
        newText.append(elementText, lastEnd, start);
      }

      currentExpressionReturnType = TypeName.get(String.class);
      String expressionString = elementText.substring(start + 2, end - 2).trim();
      String processedExpression = processExpression(expressionString);
      newText.append("{{ ").append(processedExpression).append(" }}");
      lastEnd = end;
    }
    if (lastEnd > 0) {
      newText.append(elementText.substring(lastEnd));
      outputDocument.replace(textSegment, newText.toString());
    }
  }
925921
private void processToUnicode(){
        
        PdfObject toUni = fontDic.get(PdfName.TOUNICODE);
        if (toUni != null){
            
            try {
                byte[] touni = PdfReader.getStreamBytes((PRStream)PdfReader.getPdfObjectRelease(toUni));
    
                CMapParser cmapParser = new CMapParser();
                toUnicodeCmap = cmapParser.parse(new ByteArrayInputStream(touni));
            } catch (IOException e) {
                throw new Error("Unable to process ToUnicode map - " + e.getMessage(), e);
            }
        }
    }
1281585
private void processText() {

        int length = content.length();
        int i, j, count, current_set;

        if (length > 138) {
            throw new OkapiException("Input data too long");
        }

        for (i = 0; i < 144; i++) {
            set[i] = -1;
            character[i] = 0;
        }

        for (i = 0; i < length; i++) {
            /* Look up characters in table from Appendix A - this gives
             value and code set for most characters */
            set[i] = MAXICODE_SET[inputData[i]];
            character[i] = MAXICODE_SYMBOL_CHAR[inputData[i]];
        }

        // If a character can be represented in more than one code set, pick which version to use.
        if (set[0] == 0) {
            if (character[0] == 13) {
                character[0] = 0;
            }
            set[0] = 1;
        }

        for (i = 1; i < length; i++) {
            if (set[i] == 0) {
                /* Special character that can be represented in more than one code set. */
                if (character[i] == 13) {
                    /* Carriage Return */
                    set[i] = bestSurroundingSet(i, length, 1, 5);
                    if (set[i] == 5) {
                        character[i] = 13;
                    } else {
                        character[i] = 0;
                    }
                } else if (character[i] == 28) {
                    /* FS */
                    set[i] = bestSurroundingSet(i, length, 1, 2, 3, 4, 5);
                    if (set[i] == 5) {
                        character[i] = 32;
                    }
                } else if (character[i] == 29) {
                    /* GS */
                    set[i] = bestSurroundingSet(i, length, 1, 2, 3, 4, 5);
                    if (set[i] == 5) {
                        character[i] = 33;
                    }
                } else if (character[i] == 30) {
                    /* RS */
                    set[i] = bestSurroundingSet(i, length, 1, 2, 3, 4, 5);
                    if (set[i] == 5) {
                        character[i] = 34;
                    }
                } else if (character[i] == 32) {
                    /* Space */
                    set[i] = bestSurroundingSet(i, length, 1, 2, 3, 4, 5);
                    if (set[i] == 1) {
                        character[i] = 32;
                    } else if (set[i] == 2) {
                        character[i] = 47;
                    } else {
                        character[i] = 59;
                    }
                } else if (character[i] == 44) {
                    /* Comma */
                    set[i] = bestSurroundingSet(i, length, 1, 2);
                    if (set[i] == 2) {
                        character[i] = 48;
                    }
                } else if (character[i] == 46) {
                    /* Full Stop */
                    set[i] = bestSurroundingSet(i, length, 1, 2);
                    if (set[i] == 2) {
                        character[i] = 49;
                    }
                } else if (character[i] == 47) {
                    /* Slash */
                    set[i] = bestSurroundingSet(i, length, 1, 2);
                    if (set[i] == 2) {
                        character[i] = 50;
                    }
                } else if (character[i] == 58) {
                    /* Colon */
                    set[i] = bestSurroundingSet(i, length, 1, 2);
                    if (set[i] == 2) {
                        character[i] = 51;
                    }
                }
            }
        }

        for (i = length; i < set.length; i++) {
            /* Add the padding */
            if (set[length - 1] == 2) {
                set[i] = 2;
            } else {
                set[i] = 1;
            }
            character[i] = 33;
        }

        /* Find candidates for number compression (not allowed in primary message in modes 2 and 3). */
        if (mode == 2 || mode == 3) {
            j = 9;
        } else {
            j = 0;
        }
        count = 0;
        for (i = j; i < 143; i++) {
            if (set[i] == 1 && character[i] >= 48 && character[i] <= 57) {
                /* Character is a number */
                count++;
            } else {
                count = 0;
            }
            if (count == 9) {
                /* Nine digits in a row can be compressed */
                set[i] = 6;
                set[i - 1] = 6;
                set[i - 2] = 6;
                set[i - 3] = 6;
                set[i - 4] = 6;
                set[i - 5] = 6;
                set[i - 6] = 6;
                set[i - 7] = 6;
                set[i - 8] = 6;
                count = 0;
            }
        }

        /* Add shift and latch characters */
        current_set = 1;
        i = 0;
        do {
            if ((set[i] != current_set) && (set[i] != 6)) {
                switch (set[i]) {
                    case 1:
                        if (i + 1 < set.length && set[i + 1] == 1) {
                            if (i + 2 < set.length && set[i + 2] == 1) {
                                if (i + 3 < set.length && set[i + 3] == 1) {
                                    /* Latch A */
                                    insert(i, 63);
                                    current_set = 1;
                                    length++;
                                    i += 3;
                                } else {
                                    /* 3 Shift A */
                                    insert(i, 57);
                                    length++;
                                    i += 2;
                                }
                            } else {
                                /* 2 Shift A */
                                insert(i, 56);
                                length++;
                                i++;
                            }
                        } else {
                            /* Shift A */
                            insert(i, 59);
                            length++;
                        }
                        break;
                    case 2:
                        if (i + 1 < set.length && set[i + 1] == 2) {
                            /* Latch B */
                            insert(i, 63);
                            current_set = 2;
                            length++;
                            i++;
                        } else {
                            /* Shift B */
                            insert(i, 59);
                            length++;
                        }
                        break;
                    case 3:
                        if (i + 3 < set.length && set[i + 1] == 3 && set[i + 2] == 3 && set[i + 3] == 3) {
                            /* Lock In C */
                            insert(i, 60);
                            insert(i, 60);
                            current_set = 3;
                            length++;
                            i += 3;
                        } else {
                            /* Shift C */
                            insert(i, 60);
                            length++;
                        }
                        break;
                    case 4:
                        if (i + 3 < set.length && set[i + 1] == 4 && set[i + 2] == 4 && set[i + 3] == 4) {
                            /* Lock In D */
                            insert(i, 61);
                            insert(i, 61);
                            current_set = 4;
                            length++;
                            i += 3;
                        } else {
                            /* Shift D */
                            insert(i, 61);
                            length++;
                        }
                        break;
                    case 5:
                        if (i + 3 < set.length && set[i + 1] == 5 && set[i + 2] == 5 && set[i + 3] == 5) {
                            /* Lock In E */
                            insert(i, 62);
                            insert(i, 62);
                            current_set = 5;
                            length++;
                            i += 3;
                        } else {
                            /* Shift E */
                            insert(i, 62);
                            length++;
                        }
                        break;
                    default:
                        throw new OkapiException("Unexpected set " + set[i] + " at index " + i + ".");
                }
                i++;
            }
            i++;
        } while (i < set.length);

        /* Number compression has not been forgotten! It's handled below. */
        i = 0;
        do {
            if (set[i] == 6) {
                /* Number compression */
                int value = 0;
                for (j = 0; j < 9; j++) {
                    value *= 10;
                    value += (character[i + j] - '0');
                }
                character[i] = 31; /* NS */
                character[i + 1] = (value & 0x3f000000) >> 24;
                character[i + 2] = (value & 0xfc0000) >> 18;
                character[i + 3] = (value & 0x3f000) >> 12;
                character[i + 4] = (value & 0xfc0) >> 6;
                character[i + 5] = (value & 0x3f);
                i += 6;
                for (j = i; j < 140; j++) {
                    set[j] = set[j + 3];
                    character[j] = character[j + 3];
                }
                length -= 3;
            } else {
                i++;
            }
        } while (i < set.length);

        /* Inject ECI codes to beginning of data, according to Table 3 */
        if (eciMode != 3) {
            insert(0, 27); // ECI

            if ((eciMode >= 0) && (eciMode <= 31)) {
                insert(1, eciMode & 0x1F);
                length += 2;
            }

            if ((eciMode >= 32) && (eciMode <= 1023)) {
                insert(1, 0x20 + (eciMode >> 6));
                insert(2, eciMode & 0x3F);
                length += 3;
            }

            if ((eciMode >= 1024) && (eciMode <= 32767)) {
                insert(1, 0x30 + (eciMode >> 12));
                insert(2, (eciMode >> 6) & 0x3F);
                insert(3, eciMode & 0x3F);
                length += 4;
            }

            if ((eciMode >= 32768) && (eciMode <= 999999)) {
                insert(1, 0x38 + (eciMode >> 18));
                insert(2, (eciMode >> 12) & 0x3F);
                insert(3, (eciMode >> 6) & 0x3F);
                insert(4, eciMode & 0x3F);
                length += 5;
            }
        }

        /* Make sure we haven't exceeded the maximum data length. */
        int maxLength;
        if (mode == 2 || mode == 3) {
            maxLength = 84;
        } else if (mode == 4 || mode == 6) {
            maxLength = 93;
        } else if (mode == 5) {
            maxLength = 77;
        } else {
            maxLength = 0; // impossible
        }
        if (length > maxLength) {
            throw new OkapiException("Input data too long");
        }
    }
1024151
public void process(CAS tcas) {

		String text = tcas.getDocumentText();
		Document document = new DocumentImpl(text);

		cogroo.analyze(document);

		for (Sentence sentence : document.getSentences()) {

			// create sentence annotations
			AnnotationFS sentenceAnn = tcas.createAnnotation(mSentenceType,
					sentence.getStart(), sentence.getEnd());
			tcas.getIndexRepository().addFS(sentenceAnn);

			int sentenceOffset = sentence.getStart();

			AnnotationFS[] tokenAnnotationArr = new AnnotationFS[sentence
					.getTokens().size()];
			int i = 0;
			for (Token token : sentence.getTokens()) {
				// create token annotations
				tokenAnnotationArr[i] = tcas.createAnnotation(mTokenType,
						sentenceOffset + token.getStart(), sentenceOffset
								+ token.getEnd());

				// add POSTag annotations
				tokenAnnotationArr[i].setStringValue(this.mPosFeature,
						token.getPOSTag());

				// add lexeme annotations
				tokenAnnotationArr[i].setStringValue(this.mLexemeFeature,
						token.getLexeme());

				// add lemma annotations
				StringArrayFS lemmas = tcas.createStringArrayFS(token
						.getLemmas().length);
				lemmas.copyFromArray(token.getLemmas(), 0, 0,
						token.getLemmas().length);
				tokenAnnotationArr[i].setFeatureValue(this.mLemmaFeature,
						lemmas);

				tokenAnnotationArr[i].setStringValue(this.mFeaturesFeature,
						token.getFeatures());

				tcas.getIndexRepository().addFS(tokenAnnotationArr[i]);
				i++;
			}

			// chunks
			for (Chunk chunk : sentence.getChunks()) {

				int start = sentence.getTokens().get(chunk.getStart())
						.getStart()
						+ sentenceOffset;
				int end = sentence.getTokens().get(chunk.getEnd() - 1).getEnd()
						+ sentenceOffset;

				AnnotationFS chunkAnn = tcas.createAnnotation(mChunkType,
						start, end);

				chunkAnn.setStringValue(mChunkFeature, chunk.getTag());

				if(chunk.getHeadIndex() >= 0) {
					chunkAnn.setFeatureValue(mChunkHead,
							tokenAnnotationArr[chunk.getHeadIndex()]);
				}

				tcas.getIndexRepository().addFS(chunkAnn);
			}

			// syntactic chunk
			for (SyntacticChunk sc : sentence.getSyntacticChunks()) {
				int start = sentence.getTokens().get(sc.getStart()).getStart()
						+ sentenceOffset;
				int end = sentence.getTokens().get(sc.getEnd() - 1).getEnd()
						+ sentenceOffset;

				AnnotationFS syntChunkAnn = tcas.createAnnotation(
						mSyntacticChunkType, start, end);

				syntChunkAnn.setStringValue(mSyntacticChunkFeature, sc.getTag());

				tcas.getIndexRepository().addFS(syntChunkAnn);
			}
		}
	}
34535
private void processAttribute(CValuePropertyInfo property, ClassOutline clase, Outline model) {
		FieldOutline field = model.getField(property);
		String propertyName = property.getName(false);
		String className = clase.implClass.name();

		log("Attribute " + propertyName + " added to class " + className);
		XSComponent definition = property.getSchemaComponent();
		RestrictionSimpleTypeImpl particle = (RestrictionSimpleTypeImpl) definition;
		XSSimpleType type = particle.asSimpleType();
		JFieldVar var = clase.implClass.fields().get(propertyName);


//		if (particle.isRequired()) {
//			if (!hasAnnotation(var, NotNull.class)) {
//				if (notNullAnnotations) {
//					System.out.println("@NotNull: " + propertyName + " added to class " + className);
//					var.annotate(NotNull.class);
//				}
//			}
//		}

		validAnnotation(type, var, propertyName, className);
		processType(type, var, propertyName, className);
	}
1366488
def process_text(self, kind, context):
		""""""
		
		result = None
		
		while True:
			chunk = yield None
			
			if chunk is None:
				if result:
					yield result.clone(line=repr(result.line))
				
				return
			
			if not result:
				result = chunk
				continue
			
			result.line += chunk.line
158698
protected FieldMetadata processParameterizedType( FieldDeclaration fieldDeclaration ) {
        ParameterizedType parameterizedType = (ParameterizedType)fieldDeclaration.getType();
        Type typeOfParameterizedType = parameterizedType.getType(); // type may be a simple type or a qualified type.
        FieldMetadata referenceFieldMetadata = createParameterizedFieldMetadataFrom(typeOfParameterizedType);
        // modifiers
        processModifiersOfFieldDeclaration(fieldDeclaration, referenceFieldMetadata);
        // variables

        referenceFieldMetadata.setName(getFieldName(fieldDeclaration));

        processVariablesOfVariableDeclarationFragment(fieldDeclaration, referenceFieldMetadata);
        return referenceFieldMetadata;
    }
586924
public void scanForAnnotatedFields(Types typeUtils, Elements elementUtils)
      throws ProcessingException {

    // Scan inheritance hierarchy recursively to find all annotated fields
    TypeElement currentClass = typeElement;
    TypeMirror superClassType;
    Column annotation = null;
    PackageElement originPackage = elementUtils.getPackageOf(typeElement);
    PackageElement superClassPackage;

    Set<VariableElement> annotatedFields = new LinkedHashSet<>();
    Map<String, ExecutableElement> possibleSetterFields = new HashMap<>();


    do {

      // Scan fields
      for (Element e : currentClass.getEnclosedElements()) {
        annotation = e.getAnnotation(Column.class);
        if (e.getKind() == ElementKind.FIELD && annotation != null) {
          annotatedFields.add((VariableElement) e);
        }
        // Check methods
        else if (e.getKind() == ElementKind.METHOD) {

          // Save possible setters
          ExecutableElement methodElement = (ExecutableElement) e;
          String setterMethodName = methodElement.getSimpleName().toString();

          if (setterMethodName.startsWith("set")) {
            ExecutableElement existingSetter = possibleSetterFields.get(setterMethodName);
            if (existingSetter != null) {
              // The new setter has better visibility, so pick that one
              if (ModifierUtils.compareModifierVisibility(methodElement, existingSetter) == -1) {
                possibleSetterFields.put(setterMethodName, methodElement);
              }
            } else {
              possibleSetterFields.put(setterMethodName, methodElement);
            }
          }

          // Is it an annotated setter?
          if (annotation != null) {

            ColumnAnnotatedMethod method = new ColumnAnnotatedMethod(methodElement, annotation);

            ColumnAnnotateable existingColumnAnnotateable =
                columnAnnotatedElementsMap.get(method.getColumnName());
            if (existingColumnAnnotateable != null) {
              throw new ProcessingException(methodElement,
                  "The method %s in class %s is annotated with @%s with column name = \"%s\" but this column name is already used by %s in class %s",
                  method.getMethodName(), method.getQualifiedSurroundingClassName(),
                  Column.class.getSimpleName(), method.getColumnName(),
                  existingColumnAnnotateable.getElementName(),
                  existingColumnAnnotateable.getQualifiedSurroundingClassName());
            }

            columnAnnotatedElementsMap.put(method.getColumnName(), method);
          }
        } else if (annotation != null) {
          throw new ProcessingException(e,
              "%s is of type %s and annotated with @%s, but only Fields or setter Methods can be annotated with @%s",
              e.getSimpleName(), e.getKind().toString(), Column.class.getSimpleName(),
              Column.class.getSimpleName());
        }
      }

      superClassType = currentClass.getSuperclass();
      currentClass = (TypeElement) typeUtils.asElement(superClassType);
    } while (superClassType.getKind() != TypeKind.NONE);

    // Check fields
    for (VariableElement e : annotatedFields) {

      annotation = e.getAnnotation(Column.class);
      currentClass = (TypeElement) e.getEnclosingElement();

      if (e.getModifiers().contains(Modifier.PRIVATE)) {
        // Private field: Automatically try to detect a setter
        String fieldName = e.getSimpleName().toString();

        String perfectSetterName;
        if (fieldName.length() == 1) {
          perfectSetterName = "set" + fieldName.toUpperCase();
        } else {
          String withoutHungarianNotation = HungarianNotation.removeNotation(fieldName);
          perfectSetterName = "set"
              + Character.toUpperCase(withoutHungarianNotation.charAt(0))
              + withoutHungarianNotation.substring(1);
        }

        ExecutableElement setterMethod = possibleSetterFields.get(perfectSetterName);
        if (setterMethod != null && isSetterForField(setterMethod, e)) {
          // valid setter, so use this one
          ColumnAnnotatedMethod method = new ColumnAnnotatedMethod(setterMethod, annotation);
          columnAnnotatedElementsMap.put(method.getColumnName(), method);
          continue;
        } else {

          if (fieldName.startsWith("m")) {
            // setmFoo()  if field == mFoo
            setterMethod = possibleSetterFields.get("set" + fieldName);
            if (setterMethod != null && isSetterForField(setterMethod, e)) {
              // valid setter
              ColumnAnnotatedMethod method = new ColumnAnnotatedMethod(setterMethod, annotation);
              columnAnnotatedElementsMap.put(method.getColumnName(), method);
              continue;
            } else {
              // setMFoo  if field == mFoo
              if (fieldName.length() > 1) {
                setterMethod = possibleSetterFields.get(
                    "set" + Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1));
                if (setterMethod != null && isSetterForField(setterMethod, e)) {
                  // valid setter
                  ColumnAnnotatedMethod method =
                      new ColumnAnnotatedMethod(setterMethod, annotation);
                  columnAnnotatedElementsMap.put(method.getColumnName(), method);
                  continue;
                }
              }
            }
          }
        }

         // Kotlin special boolean character treatment
        if (fieldName.matches("is[A-Z].*")) {
          String setterName = "set" + fieldName.substring(2);
          setterMethod = possibleSetterFields.get(setterName);
          if (setterMethod != null && isSetterForField(setterMethod, e)) {
            // valid setter
            ColumnAnnotatedMethod method =
                new ColumnAnnotatedMethod(setterMethod, annotation);
            columnAnnotatedElementsMap.put(method.getColumnName(), method);
            continue;
          }
        }

        throw new ProcessingException(e, "The field '%s' in class %s is private. "
            + "A corresponding setter method with the name '%s(%s)' is expected but haven't been found. Please add this setter method, "
            + "If you have another setter method named differently "
            + "please annotate your setter method with @%s ", fieldName,
            e.getEnclosingElement().getSimpleName().toString(), perfectSetterName,
            e.asType().toString(), Column.class.getSimpleName());
      } else {
        // A simple non private field
        ColumnAnnotatedField field = new ColumnAnnotatedField(e, annotation);

        // Check field visibility of super class field
        if (currentClass != typeElement && !field.getField()
            .getModifiers()
            .contains(Modifier.PUBLIC)) {

          superClassPackage = elementUtils.getPackageOf(currentClass);

          if ((superClassPackage != null && originPackage == null) || (superClassPackage == null
              && originPackage != null) || (superClassPackage != null && !superClassPackage.equals(
              originPackage)) || (originPackage != null && !originPackage.equals(
              superClassPackage))) {

            throw new ProcessingException(e,
                "The field %s in class %s can not be accessed from ObjectMapper because of "
                    + "visibility issue. Either move class %s into the same package "
                    + "as %s or make the field %s public or create and annotate a public setter "
                    + "method for this field with @%s instead of annotating the field itself",
                field.getFieldName(), field.getQualifiedSurroundingClassName(),
                typeElement.getQualifiedName().toString(), field.getQualifiedSurroundingClassName(),
                field.getFieldName(), Column.class.getSimpleName());
          }
        }

        ColumnAnnotateable existingColumnAnnotateable =
            columnAnnotatedElementsMap.get(field.getColumnName());
        if (existingColumnAnnotateable != null) {
          throw new ProcessingException(e,
              "The field %s in class %s is annotated with @%s with column name = \"%s\" but this column name is already used by %s in class %s",
              field.getFieldName(), field.getQualifiedSurroundingClassName(),
              Column.class.getSimpleName(), field.getColumnName(),
              existingColumnAnnotateable.getElementName(),
              existingColumnAnnotateable.getQualifiedSurroundingClassName());
        }

        columnAnnotatedElementsMap.put(field.getColumnName(), field);
      }
    }
  }