Returns the {@link LongMapper} represented by this {@link MapperBuilder}.

@param field the name of the field to be built
@return the {@link LongMapper} represented by this
184755
@Override
    public LongMapper build(String field) {
        return new LongMapper(field, column, validated, boost);
    }
931895
public SchemaBuilder mapper(String field, MapperBuilder<?, ?> mapper) {
        mapperBuilders.put(field, mapper);
        return this;
    }
78309
private LinkedHashMap<String, Long> getPrefixRefs(String field) {
    if (fieldReferences.containsKey(field)) {
      FieldReferences fr = fieldReferences.get(field);
      if (!prefixReferences.containsKey(field)) {
        LinkedHashMap<String, Long> refs = new LinkedHashMap<String, Long>();
        try {
          IndexInput inPrefix = indexInputList.get("prefix");
          inPrefix.seek(fr.refPrefix);
          for (int i = 0; i < fr.numberOfPrefixes; i++) {
            Long ref = inPrefix.getFilePointer();
            String prefix = inPrefix.readString();
            refs.put(prefix, ref);
          }
        } catch (Exception e) {
          log.error(e);
          refs.clear();
        }
        prefixReferences.put(field, refs);
        return refs;
      } else {
        return prefixReferences.get(field);
      }
    } else {
      return null;
    }
  }
941892
public static Field get(final long _id)
    {
        Field ret = null;
        final Cache<Long, Field> cache = InfinispanCache.get().<Long, Field>getCache(Field.IDCACHE);
        if (cache.containsKey(_id)) {
            ret = cache.get(_id);
        } else {
            AbstractCollection col = null;
            try {
                final QueryBuilder queryBldr = new QueryBuilder(CIAdminUserInterface.Field);
                queryBldr.addWhereAttrEqValue(CIAdminUserInterface.Field.ID, _id);
                final MultiPrintQuery multi = queryBldr.getPrint();
                multi.addAttribute(CIAdminUserInterface.Field.Collection);
                multi.executeWithoutAccessCheck();

                if (multi.next()) {
                    final Long colId = multi.<Long> getAttribute(CIAdminUserInterface.Field.Collection);
                    col = Form.get(colId);
                    if (col == null) {
                        col = Table.get(colId);
                    }
                }
            } catch (final EFapsException e) {
                Field.LOG.error("get(long)", e);
            }
            if (col != null) {
                ret = col.getFieldsMap().get(_id);
                if (ret != null) {
                    cache.put(_id, ret);
                }
            }
        }
        return ret;
    }
182148
public long getFieldAsLong(int tag, int index) {
        Integer i = (Integer)fieldIndex.get(Integer.valueOf(tag));
        return fields[i.intValue()].getAsLong(index);
    }
479245
public static String getMapFieldAddAllName(Field field) {
        if (field.isMap()) {
            return "putAll" + Formatter.toPascalCase(field.getName());
        }
        throw new IllegalArgumentException(field.toString());
    }
996047
public static String getMapGetterName(Field field) {
        if (field.isMap()) {
            return GETTER_PREFIX + Formatter.toPascalCase(field.getName()) + MAP_SUFFIX;
        }
        throw new IllegalArgumentException(field.toString());
    }
306443
public static Map<String,Object> addFieldParam(Map<String,Object> map, Field field)
    {
        if (!field.isNull())
            map.put(field.getFieldName(), field.toString());
        return map;
    }
344276
public static Mapping<Long> longv(Constraint... constraints) {
        return new FieldMapping(
                InputMode.SINGLE,
                mkSimpleConverter(s ->
                    isEmptyStr(s) ? 0l : Long.parseLong(s)
                ), new MappingMeta(MAPPING_LONG, Long.class)
            ).constraint(checking(Long::parseLong, "error.long", true))
                .constraint(constraints);
        }
722122
private TableFieldSchema getSchemaOfRepeatedFields(Field field) {
    Class<?> parameterType = BigQueryFieldUtil.getParameterTypeOfRepeatedField(field);
    TableFieldSchema tf = parseFieldAnnotations(field);
    tf.setMode(BigQueryFieldMode.REPEATED.getValue());
    if (BigqueryFieldMarshallers.getMarshaller(parameterType) != null) {
      return tf.setType(BigQueryDataTypeUtil.getBigQueryType(
          BigqueryFieldMarshallers.getMarshaller(parameterType).getSchemaType()));
    }
    tf.setType(BigQueryConstants.RECORD_TYPE);
    return tf.setFields(getSchema(parameterType));
  }
617231
public static Class<?> getGenericTypeOfCollectionField(Field field) {
        Type genericType = field.getGenericType();

        if (!(genericType instanceof ParameterizedType)) {
            throw new IllegalArgumentException("Field is not a ParameterizedType.");
        }

        Type[] genericTypes = ((ParameterizedType) genericType).getActualTypeArguments();


        if (genericTypes.length != 1) {
            throw new IllegalArgumentException("Field does not have a single generic type.");
        }

        if (!(genericTypes[0] instanceof Class)) {
            throw new IllegalArgumentException("Field's generic type is not a class?");
        }

        return (Class<?>) genericTypes[0];
    }
692711
@Override
    public IntegerMapper build(String field) {
        return new IntegerMapper(field, column, validated, boost);
    }
1315278
public AnnotationValueBuilder<T> member(String name, long... longs) {
        if (longs != null) {
            values.put(name, longs);
        }
        return this;
    }
1098654
public AnnotatedTypeBuilder<X> addToField(AnnotatedField<? super X> field, Annotation annotation) {
       return addToField(field.getJavaMember(), annotation);
   }
531993
private Multimap<String, I_CmsFormField> getFieldsByGroup(Collection<I_CmsFormField> fields) {

        Multimap<String, I_CmsFormField> result = ArrayListMultimap.create();
        for (I_CmsFormField field : fields) {
            String group = field.getLayoutData().get(LD_GROUP);
            result.put(group, field);
        }
        return result;
    }
635781
static long sizeForField(@Nonnull String key, @Nonnull Object value) {
        return key.length() + sizeForValue(value);
    }
646518
public static String getMapFieldValueType(Field field) {
        FieldType type = field.getType();
        if (!(type instanceof Message)) {
            throw new IllegalArgumentException(field.toString());
        }
        Message entryType = (Message) type;
        Type valueType = entryType.getField(MAP_ENTRY_VALUE).getType();
        String v;
        if (valueType instanceof ScalarFieldType) {
            ScalarFieldType scalarValueType = (ScalarFieldType) valueType;
            v = ScalarFieldTypeUtil.getWrapperType(scalarValueType);
        } else {
            UserType userType = (UserType) valueType;
            v = UserTypeUtil.getCanonicalName(userType);
        }
        return v;
    }