import hudson.util.CopyOnWriteList; //导入依赖的package包/类
@Override
public void fromDBObject(DBObject dbObject, MappedField mf, Object entity, EntityCache cache, Mapper mapper) {
    BasicDBList cowlist = (BasicDBList) dbObject.get(mf.getNameToStore());

    if (cowlist == null)
        throw new IllegalArgumentException("Improperly formatted DBObject for CopyOnWriteList");

    List core = new ArrayList();
    for (Object obj : cowlist) {
        DBObject listEntryDbObj = (DBObject) obj;

        // Hack until we can coax MappedField to understand what CopyOnWriteList is. Eliminate as soon as possible.
        // Currently mf.getSubType() is null because MappedField does not use Iterable to determine a list and thus
        // does not check for subtypes.
        Class clazz = mapper.getOptions().getObjectFactory().createInstance(mapper, mf, listEntryDbObj).getClass();

        core.add(mapper.fromDBObject(clazz, listEntryDbObj, cache));
    }
    mf.setFieldValue(entity, new CopyOnWriteList(core));
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
@Override
public Object decode(Class targetClass, Object fromDBObject, MappedField optionalExtraInfo) {
    if (fromDBObject == null) return null;

    BasicDBList rawList = (BasicDBList) fromDBObject;

    List core = new ArrayList();
    for (Object obj : rawList) {
        DBObject dbObj = (DBObject) obj;
        core.add(getMapper().fromDBObject(optionalExtraInfo.getSubClass(), dbObj, getMapper().createEntityCache()));
    }

    return new CopyOnWriteList(core);
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
@Override
public Object encode(Object value, MappedField optionalExtraInfo) {
    if (value == null) return null;

    CopyOnWriteList copyOnWriteList = (CopyOnWriteList) value;
    List core = new BasicDBList();

    for (Object obj : copyOnWriteList) {
        core.add(getMapper().toDBObject(obj));
    }

    return core;
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
@Override
public void toDBObject(Object entity, MappedField mf, DBObject dbObject, Map<Object, DBObject> involvedObjects, Mapper mapper) {
    final String name = mf.getNameToStore();
    CopyOnWriteList copyOnWriteList = (CopyOnWriteList) mf.getFieldValue(entity);
    List core = new ArrayList();

    mf.getSubType();

    for (Object obj : copyOnWriteList) {
        core.add(mapper.toDBObject(obj, involvedObjects));
    }

    dbObject.put(name, core);
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
@Override
public DBObject toDBObject(final Object entity, final Map<Object, DBObject> involvedObjects) {
    if (!(entity instanceof CopyOnWriteList || involvedObjects.containsKey(entity))) {
        involvedObjects.put(entity, null);
    }

    return super.toDBObject(entity, involvedObjects);
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
JenkinsEmbeddedMapper() {
    this.customMappers = new HashMap<>();
    this.customMappers.put(CopyOnWriteList.class, new CopyOnWriteListMapper());

    this.serializationMethodInvoker = new SerializationMethodInvoker();

    this.awkwardMapper = new MapKeyValueMapper();
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
/** JENKINS-27669: try to preload classes that will be needed by {@link #publish} */
CustomHandler() {
    Arrays.hashCode(new Class<?>[] {
        Map.Entry.class,
        LogRecorder.class,
        LogRecorder.Target.class,
        LogFile.class,
        RewindableFileOutputStream.class,
        RewindableRotatingFileOutputStream.class,
        StreamHandler.class,
        SupportLogFormatter.class,
        LogFlusher.class,
        CopyOnWriteList.class,
    });
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
private static void fixProperties(AbstractProject implementationProject, TemplateImplementationProperty property, boolean implementationIsTemplate) throws IOException {
    CopyOnWriteList<JobProperty<?>> properties = ReflectionUtils.getFieldValue(Job.class, implementationProject, "properties");
    properties.add(property);

    if (!implementationIsTemplate) {
        for (JobProperty<?> jobProperty : properties) {
            if (jobProperty instanceof TemplateProperty) {
                properties.remove(jobProperty);
            }
        }
    }
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
public CopyOnWriteListConverter() {
    super(CopyOnWriteList.class);
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
/**
* The getter for the packageItems field. (this field is set by the UI part of this plugin see config.jelly file)
*
* @return the value of the packageItems field
*/
public CopyOnWriteList<PackageItem> getPackageItems() {
    return packageItems;
}
 

import hudson.util.CopyOnWriteList; //导入依赖的package包/类
/**
 * constructor
 *
 * @param mapper
 */
public CopyOnWriteListMappedClass(final Mapper mapper) {
    super(CopyOnWriteList.class, mapper);
}