Copy this section configuration on another section. Note that this method should only be used with
targetSections that have no idMap.
@param {aria.templates.Section} targetSection
427684
function (targetSection) {
                this.$assert(708, targetSection.idMap == null); // check that there is no id map so that it is not a
                // problem to change the id
                targetSection.id = this.id;
                targetSection.domType = this.domType;
                targetSection.tableNav = this.tableNav;
                targetSection.keyMap = this.keyMap;
                targetSection.macro = this.macro;
            }
580413
public void removeTickLabelSection(final Section SECTION) {
        if (null == SECTION) return;
        tickLabelSections.remove(SECTION);
        Collections.sort(tickLabelSections, new SectionComparator());
        fireUpdateEvent(REDRAW_EVENT);
    }
710738
function toggleTargetState( element ) {
  if ( element.classList.contains( this.classes.targetExpanded ) ) {
    this.ui.target.classList.add( this.classes.targetCollapsed );
    this.ui.target.classList.remove( this.classes.targetExpanded );
  } else {
    this.ui.target.classList.add( this.classes.targetExpanded );
    this.ui.target.classList.remove( this.classes.targetCollapsed );
  }
}
873823
function(targets){
            targets = targets || [];
            this.targets = targets;
            this.map.reset();
            for(var i = targets.length - 1; i >= 0; i--){
                var target = targets[i];
                this.map.add(target.x, target.y, target);
            }
        }
1343341
function (args) {
                var sectionMacro = this.macro;
                if (sectionMacro) {
                    // a macro is defined in the section, it is the default macro to use when refreshing
                    if (!args.macro) {
                        args.macro = sectionMacro;
                    } else {
                        var targetMacro = args.macro;
                        if (ariaUtilsType.isObject(targetMacro) && !targetMacro.name) {
                            targetMacro.name = sectionMacro.name;
                            targetMacro.scope = sectionMacro.scope;
                            if (!targetMacro.args) {
                                targetMacro.args = sectionMacro.args;
                            }
                        }
                    }
                }
                // Remove cached reference to the dom element, as it may change during the refresh
                // (occurs in tables in IE)
                this._domElt = null;
            }
1023459
public void removeSection(final Section SECTION) {
        if (null == SECTION) return;
        sections.remove(SECTION);
        Collections.sort(sections, new SectionComparator());
        fireUpdateEvent(SECTION_EVENT);
    }
58659
public void copyValuesFromTo(Collection<Object> source, List<Object> target) {
        target.addAll(source);
    }
574150
public void copy(Datastream target) {

        target.isNew = isNew;
        target.DatastreamID = DatastreamID;
        if (DatastreamAltIDs != null) {
            target.DatastreamAltIDs = new String[DatastreamAltIDs.length];
            for (int i = 0; i < DatastreamAltIDs.length; i++) {
                target.DatastreamAltIDs[i] = DatastreamAltIDs[i];
            }
        }
        target.DSFormatURI = DSFormatURI;
        target.DSMIME = DSMIME;
        target.DSControlGrp = DSControlGrp;
        target.DSInfoType = DSInfoType;
        target.DSState = DSState;
        target.DSVersionable = DSVersionable;
        target.DSVersionID = DSVersionID;
        target.DSLabel = DSLabel;
        target.DSCreateDT = DSCreateDT;
        target.DSSize = DSSize;
        target.DSLocation = DSLocation;
        target.DSLocationType = DSLocationType;
        target.DSChecksumType = DSChecksumType;
        target.DSChecksum = DSChecksum;
    }
59376
def _set_configspec(self, section, copy):
        
        configspec = section.configspec
        many = configspec.get('__many__')
        if isinstance(many, dict):
            for entry in section.sections:
                if entry not in configspec:
                    section[entry].configspec = many

        for entry in configspec.sections:
            if entry == '__many__':
                continue
            if entry not in section:
                section[entry] = {}
                section[entry]._created = True
                if copy:
                    # copy comments
                    section.comments[entry] = configspec.comments.get(entry, [])
                    section.inline_comments[entry] = configspec.inline_comments.get(entry, '')

            # Could be a scalar when we expect a section
            if isinstance(section[entry], Section):
                section[entry].configspec = configspec[entry]
385627
public void addSection(String section, ConfigParams sectionParams) {
		if (section == null)
			throw new NullPointerException("Section name cannot be null");

		if (sectionParams != null) {
			for (Map.Entry<String, String> entry : sectionParams.entrySet()) {
				String key = entry.getKey();

				if (key.length() > 0 && section.length() > 0)
					key = section + "." + key;
				else if (key.length() == 0)
					key = section;

				String value = entry.getValue();

				put(key, value);
			}
		}
	}
495468
protected function copyElement(DOMElement $source, DOMElement $target)
	{
		if ($source->hasAttributes())
		{
			$attributes = $source->attributes;
			if (!is_null($attributes))
			{
				foreach ($attributes as $attr)
				{
					$target->setAttribute($attr->name, $attr->value);
				}
			}
		}

		foreach ($source->childNodes as $child)
		{
			$target->appendChild($child->cloneNode(true));
		}
	}
6342
function copyIntoPlace(extractedPath, targetPath) {
  log.info('Removing', targetPath);
  return kew.nfcall(fs.remove, targetPath).then(function () {
    // Look for the extracted directory, so we can rename it.
    const files = fs.readdirSync(extractedPath);
    for (let i = 0; i < files.length; i++) {
      const file = path.join(extractedPath, files[i]);
      if (fs.statSync(file).isDirectory() && file.indexOf(helper.version) !== -1) {
        log.info('Copying extracted folder', file, '->', targetPath);
        return kew.nfcall(fs.move, file, targetPath);
      }
    }
    log.info('Could not find extracted file', files);
    throw new Error('Could not find extracted file');
  });
}
1137779
public void copyFrom(PolicyInfo other) throws IOException {
    if (other.conf != null) {
      this.conf = other.conf;
    }
    if (other.description != null && other.description.length() > 0) {
      this.description = other.description;
    }
    if (other.srcPath != null) {
      this.srcPath = other.srcPath;
    }
    for (Object key : other.properties.keySet()) {
      String skey = (String) key;
      this.properties.setProperty(skey, other.properties.getProperty(skey));
    }
    
    if (other.destPath != null) {
      for (PathInfo p:destPath) {
        this.addDestPath(p.rpath.toString(), p.myproperties);
      }
    }
  }
1302207
public void addSection(final Section SECTION) {
        if (null == SECTION) return;
        getSections().add(SECTION);
        getSections().sort(new SectionComparator());
        fireTileEvent(SECTION_EVENT);
    }
884967
private void fillPropertyMap(Map<String, Set<String>> map, TransformationDescription description) {
        for (TransformationStep step : description.getTransformingSteps()) {
            if (step.getSourceFields() == null) {
                LOGGER.debug("Step {} is ignored since no source properties are defined");
                continue;
            }
            String targetField = step.getTargetField();
            if (!map.containsKey(targetField) && isTemporaryProperty(targetField)) {
                LOGGER.debug("Add new property entry for field {}", targetField);
                map.put(targetField, new HashSet<String>());
            }
            for (String sourceField : step.getSourceFields()) {
                if (sourceField == null) {
                    continue;
                }
                String[] result = StringUtils.split(sourceField, ".");
                String mapValue = result[0];            
                
                Set<String> targets = map.get(mapValue);
                if (targets != null) {
                    targets.add(targetField);
                } else {
                    LOGGER.error("Accessed property with the name {} which isn't existing", mapValue);
                }
            }
        }
    }
735724
public static void copyToView(
			MemorySegment[] segments,
			int offset,
			int sizeInBytes,
			DataOutputView target) throws IOException {
		for (MemorySegment sourceSegment : segments) {
			int curSegRemain = sourceSegment.size() - offset;
			if (curSegRemain > 0) {
				int copySize = Math.min(curSegRemain, sizeInBytes);

				byte[] bytes = allocateReuseBytes(copySize);
				sourceSegment.get(offset, bytes, 0, copySize);
				target.write(bytes, 0, copySize);

				sizeInBytes -= copySize;
				offset = 0;
			} else {
				offset -= sourceSegment.size();
			}

			if (sizeInBytes == 0) {
				return;
			}
		}

		if (sizeInBytes != 0) {
			throw new RuntimeException("No copy finished, this should be a bug, " +
					"The remaining length is: " + sizeInBytes);
		}
	}
705522
public void addTickMarkSection(final Section SECTION) {
        if (null == SECTION) return;
        tickMarkSections.add(SECTION);
        Collections.sort(tickMarkSections, new SectionComparator());
        fireUpdateEvent(REDRAW_EVENT);
    }