Java 类org.codehaus.jackson.annotate.JsonIgnore 实例源码

@JsonIgnore
public Font getFont(){
    if(this.font==null){
        int fontStyle=Font.PLAIN;
        if((bold!=null && bold) && (italic!=null && italic)){
            fontStyle=Font.BOLD|Font.ITALIC;                
        }else if(bold!=null && bold){
            fontStyle=Font.BOLD;                            
        }else if(italic!=null && italic){
            fontStyle=Font.ITALIC;                          
        }
        double size=fontSize * 1.1;
        BigDecimal bigData=Utils.toBigDecimal(size);
        int s=bigData.setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
        this.font=new Font(fontFamily,fontStyle,s);
    }
    return this.font;
}

/**
 * Build an extraction function model object.
 *
 * @return  Take the internal namespaces and construct a model object for the extraction functions.
 */
@JsonIgnore
@Override
public Optional<ExtractionFunction> getExtractionFunction() {

    List<ExtractionFunction> extractionFunctions = getNamespaces().stream()
            .map(
                    namespace -> new LookupExtractionFunction(
                            new NamespaceLookup(namespace),
                            false,
                            "Unknown " + namespace,
                            false,
                            true
                    )
            ).collect(Collectors.toList());

    return Optional.ofNullable(
            extractionFunctions.size() > 1 ?
                    new CascadeExtractionFunction(extractionFunctions) :
                    extractionFunctions.size() == 1 ? extractionFunctions.get(0) : null
    );
}

/**
 * Build an extraction function model object.
 *
 * @return  Take the internal namespaces and construct a model object for the extraction functions.
 */
@Override
@JsonIgnore
public Optional<ExtractionFunction> getExtractionFunction() {

    List<ExtractionFunction> extractionFunctions = getLookups().stream()
            .map(
                    lookup -> new RegisteredLookupExtractionFunction(
                            lookup,
                            false,
                            "Unknown " + lookup,
                            false,
                            true
                    )
            ).collect(Collectors.toList());

    return Optional.ofNullable(
            extractionFunctions.size() > 1 ?
                    new CascadeExtractionFunction(extractionFunctions) :
                    extractionFunctions.size() == 1 ? extractionFunctions.get(0) : null
    );
}

@JsonIgnore
public String getBaseURL() {
  StringBuilder builder = new StringBuilder(protocol.toString());
  builder.append("://");
  builder.append(address);
  builder.append(":");
  builder.append(port);
  return builder.toString();
}

/**
 * @deprecated removed if not used and if it is used, make sure it returns the right information
 */
@JsonIgnore
@Deprecated
public String getURL() {
  StringBuilder builder = new StringBuilder(getBaseURL());
  if (publisher == null && topic != null) {
    builder.append(topic);
    builder.append("/");
  }
  builder.append(path);
  return builder.toString();
}

@JsonIgnore
public boolean isUpdated() {
  if (!isUpdated) {
    for (StatePair statePair : pool.values()) {
      // if one of the states have changed, then the pool is dirty
      if (statePair.getState().isUpdated()) {
        isUpdated = true;
        return true;
      }
    }
  }
  return isUpdated;
}

@JsonIgnore
@Override
public List<String> getBranches() {
    if (this.getPush() == null || this.getPush().getChanges() == null) {
        return new ArrayList<>();
    }
    return this.getPush().getChanges()
            .stream()
            .filter(bitbucketPushChange -> bitbucketPushChange != null && bitbucketPushChange.getNew() != null)
            .map(bitbucketPushChange -> bitbucketPushChange.getNew().getName())
            .collect(Collectors.toList());
}

@JsonIgnore
public boolean isUpdated() {
  if (!isUpdated) {
    for (StatePair statePair : pool.values()) {
      // if one of the states have changed, then the pool is dirty
      if (statePair.getState().isUpdated()) {
        isUpdated = true;
        return true;
      }
    }
  }
  return isUpdated;
}

@JSONField(serialize = false)
@JsonIgnore
public JSONObject getJSONData() {
    if (data == null) {
        return null;
    }
    return JSON.parseObject(data.toString());
}

@JSONField(serialize = false)
@JsonIgnore
@SuppressWarnings("unchecked")
public <T> T getValue(String key) {
    if (data instanceof String) {
        return JsonUtils.get(JSON.parseObject((String) data), key);
    }
    if (data instanceof JSONObject) {
        return JsonUtils.get((JSONObject) (data), key);
    }
    if (data instanceof Map) {
        return JsonUtils.get(new JSONObject((Map<String, Object>) data), key);
    }
    return null;
}

@JsonIgnore
public int getSeedUrlsCount() {
  if (CollectionUtils.isEmpty(seedUrls)) {
    return 0;
  }
  return seedUrls.size();
}

/**
 * Returns whether the data within this UserData object is expired, and
 * thus must not be used, according to the timestamp returned by
 * getExpires().
 *
 * @return
 *     true if the data within this UserData object is expired and must not
 *     be used, false otherwise.
 */
@JsonIgnore
public boolean isExpired() {

    // Do not bother comparing if this UserData object does not expire
    Long expirationTimestamp = getExpires();
    if (expirationTimestamp == null)
        return false;

    // Otherwise, compare expiration timestamp against system time
    return System.currentTimeMillis() > expirationTimestamp;

}

@JsonIgnore
public String getSortableMonth() {
    if (deadline == null) {
        logger.error("Deadline is NULL for the document: " + this);
        return "";
    }
    return deadline.getYear() + "/" +  deadline.getMonthValue();
}

@JsonIgnore
public boolean isUpdated() {
  if (!isUpdated) {
    for (StatePair statePair : pool.values()) {
      // if one of the states have changed, then the pool is dirty
      if (statePair.getState().isUpdated()) {
        isUpdated = true;
        return true;
      }
    }
  }
  return isUpdated;
}

@Override
@JsonIgnore
public PrimaryKey getPrimaryKey() {
    Map<Schema.Field, Object> values = new HashMap<>();
    values.put(new Schema.Field(SchemaFieldInfo.ID, Schema.Type.LONG), id);
    return new PrimaryKey(values);
}

@JsonIgnore
public String getLanguageByLid() {
    if (languages != null) {
        for (Iterator<Language> it = languages.iterator(); it.hasNext();) {
            Language lang = it.next();
            if (lang.getLid() == lid) {
                return lang.getLanguage();
            }
        }
    }
    return "C";
}

@JsonIgnore
public void getLanguageIdByKey() {
    if (languages != null) {
        for (Iterator<Language> it = languages.iterator(); it.hasNext();) {
            Language lang = it.next();
            if (lang.getKey().equals(key)) {
                lid = lang.getLid();
                return;
            }
        }
        lid = 1;
    }
}

@XmlElementWrapper(name = "Operations")
@XmlElement(name = "operation")
@JsonIgnore
public List<BulkResponses> getOperations() {

    return this.Operations;
}

@JsonIgnore
@XmlElementWrapper(name = "Operations")
@XmlElement(name = "operation")
public List<BulkRequests> getOperations() {

    return this.Operations;
}

@XmlElementWrapper(name = "Operations")
@XmlElement(name = "operation")
@JsonIgnore
public List<BulkResponse> getOperations() {

    return this.Operations;
}

@XmlElementWrapper(name = "Operations")
@XmlElement(name = "operation")
@JsonIgnore
public List<BulkResponses> getOperations() {

    return this.Operations;
}

@JsonIgnore
@XmlElementWrapper(name = "Operations")
@XmlElement(name = "operation")
public List<BulkRequests> getOperations() {

    return this.Operations;
}

@JsonIgnore
public synchronized void saveTo(File file) throws IOException {
    if(file == null) {
        throw new IllegalArgumentException("file is null");
    }

    JsonSerializer serializer = new JsonSerializer();
    serializer.toJsonFile(file, this);
}

@Nonnull
@Override
@JsonIgnore
public Date getDate()
{
    return getPullRequest().getCreatedOn();
}

@JsonIgnore
public synchronized void saveTo(File file) throws IOException {
    if(file == null) {
        throw new IllegalArgumentException("file is null");
    }

    JsonSerializer serializer = new JsonSerializer();
    serializer.toJsonFile(file, this);
}

@JsonIgnore
public Integer getDateProgressInPercent() {
    float elapsedDays = getElapsedDays();
    float totalDays = getDurationInDays();
    if (elapsedDays <= 0) {
        return 0;
    }
    if (elapsedDays > totalDays) {
        return 100;
    }
    return Float.valueOf((elapsedDays / totalDays) * 100f).intValue();
}

@JsonIgnore
@XmlTransient
public boolean matchesInputFilter(final String filter) {
    if (filter == null || filter.isEmpty()) {
        return true;
    }
    if (this.getFullNameWithUserName() == null || this.
            getFullNameWithUserName().isEmpty()) {
        return false;
    }
    return this.getFullNameWithUserName().toLowerCase().contains(filter.
            toLowerCase());
}

@JsonIgnore
@Override
public PrimaryKey getPrimaryKey() {
    Map<Schema.Field, Object> fieldToObjectMap = new HashMap<Schema.Field, Object>();
    fieldToObjectMap.put(new Schema.Field("id", Schema.Type.LONG), this.id);
    return new PrimaryKey(fieldToObjectMap);
}

@JsonIgnore
public synchronized void saveTo(File file) throws IOException {
    if(file == null) {
        throw new IllegalArgumentException("file is null");
    }

    JsonSerializer serializer = new JsonSerializer();
    serializer.toJsonFile(file, this);
}

@JsonIgnore
public synchronized void saveTo(File file) throws IOException {
    if(file == null) {
        throw new IllegalArgumentException("file is null");
    }

    JsonSerializer serializer = new JsonSerializer();
    serializer.toJsonFile(file, this);
}

@JsonIgnore
public List<Taxonomy> getClassifiableTaxonomyTree() {
    ArrayList<Taxonomy> list = new ArrayList<Taxonomy>();
    if(this.tree.isEmpty()) {
        return list;
    } else {
        for(Taxonomy tax : this.tree) {
            String rank = tax.getRank();
            if(rank != null && !rank.isEmpty() && !rank.equalsIgnoreCase("no rank")) {
                list.add(tax);
            }
        }
        return list;
    }
}

@JsonIgnore
private static QMQualityIndicator getQualityIndicator(
        IQMTreeNode<String> node) {
    if (node instanceof QMQualityIndicator) {
        return (QMQualityIndicator) node;
    }
    if (node.getParent() == null) {
        return null;
    }
    return getQualityIndicator(node.getParent());
}

@JsonIgnore
public Number getMetric(String groupKey, String key) {
    Map<String, Map<String, Number>> data = this.data;
    if (data == null) {
        return null;
    } else {
        Map<String, Number> metricMap = data.get(groupKey);
        if (metricMap == null || metricMap.isEmpty()) {
            return null;
        } else {
            return metricMap.get(key);
        }
    }
}

@JsonIgnore
public final String getChildrenString(final String prefix,
                                      final String suffix) {

    String builder = prefix +
            StringUtils.join(getChildren(), ", ") +
            suffix;
    return builder;
}

/**
 * Returns max bounding box for given SRS EPSG_4326
 * @return BoundingBox
 */
@XmlTransient
@JsonIgnore
public BoundingBox getBoundingBoxForSrsEPSG_4326() {
    if (boundingBox==null)
        return null;

    for (int i =0; i<boundingBox.length; i++)
        if(boundingBox[i].getSrs().equals("EPSG:4326"))
            return boundingBox[i];

    return null;
}

@JsonIgnore
public final void addReferredEntity(String guid, AtlasEntity entity) {
    Map<String, AtlasEntity> r = this.referredEntities;

    if (r == null) {
        r = new HashMap<>();

        this.referredEntities = r;
    }

    if (guid != null) {
        r.put(guid, entity);
    }
}

@JsonIgnore
public synchronized void saveTo(File file) throws IOException {
    if(file == null) {
        throw new IllegalArgumentException("file is null");
    }

    JsonSerializer serializer = new JsonSerializer();
    serializer.toJsonFile(file, this);
}

@JsonIgnore
@Override
public void compact() {
    super.compact();

    // remove 'entity' from referredEntities
    if (entity != null) {
        removeEntity(entity.getGuid());
    }
}

@JsonIgnore
public List<AtlasEntityHeader> getEntitiesByOperation(EntityOperation op) {
    if ( mutatedEntities != null) {
        return mutatedEntities.get(op);
    }
    return null;
}

@JsonIgnore
public List<AtlasEntityHeader> getDeletedEntities() {
    if ( mutatedEntities != null) {
        return mutatedEntities.get(EntityOperation.DELETE);
    }
    return null;
}