Add template or complement basecalled event data.
        
        :param section: Either template or complement.
        :param data: Event data table to be written.
979748
def add_event_data(self, section, data):
        
        event_group = 'BaseCalled_{}'.format(section)
        if not event_group in self.handle.handle['Analyses/{}'.format(self.group_name)]:
            self.handle.add_analysis_subgroup(self.group_name, event_group)
        self.handle.add_analysis_dataset('{}/{}'.format(self.group_name, event_group), 'Events', data)
974408
function( data ){

            // interpred data as either dom node or event data
            var el = (data instanceof PIXI.Graphics && data) || (data.body && data.body.view);

            if ( el ){
                // attach to viewport
                this.stage.addChild( el );
            }

            return this;
        }
820534
public function setSection(string $section, array $data): self
    {
        $this->propertyData[$section] = $data;
        return $this;
    }
947606
def offset_data(data_section, offset, readable = False, wraparound = False):
    
    for pos in range(0, len(data_section)/2):
        data_section = offset_byte_in_data(data_section, offset, pos, readable, wraparound)

    return data_section
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);
			}
		}
	}
970285
function (section, skipInsertHTML, refreshArgs) {
            // PROFILING // var profilingId = this.$startMeasure("Inserting section in DOM from " +
            // PROFILING // this.tplClasspath);
            var differed;
            var params = this._cfg;
            var tpl = this._tpl;
            var domElt = section.id ? section.getDom() : params.tplDiv;

            if (domElt) {
                if (!skipInsertHTML) {
                    section.insertHTML(domElt, refreshArgs);
                }
                if (!section.id) {
                    // the whole template is being refreshed; let's apply the correct size
                    // to its DOM container
                    ariaTemplatesLayout.setDivSize(domElt, tpl.$width, tpl.$height, 'hidden');
                }

                // update expando of container
                ariaUtilsDelegate.addExpando(domElt, section.delegateId);

                differed = section.initWidgets();
                this.__processDifferedItems(differed);
            } else {
                // TODO: LOG ERROR
            }
            if (!skipInsertHTML) {
                // Redundant, but makes sure that insertSection doesn't dispose the template
                this.$assert(743, params.tplDiv && tpl);
                ariaUtilsDom.refreshDomElt(params.tplDiv);
            }
            // PROFILING // this.$stopMeasure(profilingId);
        }
756686
public final void addData(@NonNull Data<?> data) {
        checkNotNull(data, "data");
        // Clear error message now, in case the caller recently replaced them.
        // If they did, they'd expect the error message to be gone, because the
        // view visibility state is reset.
        if (mDatas.isEmpty()) {
            mErrorMessage = null;
        }
        mDatas.add(data);
        mDataWatcher.setDatas(mDatas);
        updateViews();
    }
444759
def add_section(self, name):
        

        assert isinstance(name, str)

        # Skip existing sections
        for section in self.sections:
            if section.name == name:
                return section

        item = defaults["common"].copy()
        item["name"] = name

        item["itemType"] = "section"

        item = self.add_item(item)
        self.sections.append(item)

        return item
562706
def add_or_update(self, section, key, value):
        
        updates = self.update(section, key, value)
        if updates == 0:
            self.add(section, key, value)
        return updates
137282
def put_event(self, data):
        
        try:
            event = self._factory.create(data)
            self._events.put(event)
        except Full:
            raise GerritError("Unable to add event: queue is full")
1035910
def section(self, section):
        
        if isinstance(section, list):
            for h in section:
                self.add_section(h)
        else:
            self.add_section(section)
31942
def section(self, section):
        
        if not isinstance(self._container, ConfigUpdater):
            raise ValueError("Sections can only be added at section level!")
        if isinstance(section, str):
            # create a new section
            section = Section(section, container=self._container)
        elif not isinstance(section, Section):
            raise ValueError("Parameter must be a string or Section type!")
        if section.name in [block.name for block in self._container
                            if isinstance(block, Section)]:
            raise DuplicateSectionError(section.name)
        self._container.structure.insert(self._idx, section)
        self._idx += 1
        return self
1163539
public void addDataElement(String elemName, String content, Attributes attrs) {
        writeDataElement(elemName, attrs, content);
    }
1129896
def merge_modified_section_data(self):
        """"""
        
        for section in self.sections:
            section_data_start = adjust_FileAlignment( section.PointerToRawData,
                self.OPTIONAL_HEADER.FileAlignment )
            section_data_end = section_data_start+section.SizeOfRawData
            if section_data_start < len(self.__data__) and section_data_end < len(self.__data__):
                self.__data__ = self.__data__[:section_data_start] + section.get_data() + self.__data__[section_data_end:]
1363948
def add_section(self, section):
        

        if not issubclass(section.__class__, SubSection):
            raise TypeError("Argument should be a subclass of SubSection, \
                             not :" + str(section.__class__))
        self.sections[section.name] = section
        return section
1318099
def add(self, child):
        

        if isinstance(child, Run):
            self.add_run(child)
        elif isinstance(child, Record):
            self.add_record(child)
        elif isinstance(child, EventRecord):
            self.add_event_record(child)
        elif isinstance(child, DataDisplay):
            self.add_data_display(child)
        elif isinstance(child, DataWriter):
            self.add_data_writer(child)
        elif isinstance(child, EventWriter):
            self.add_event_writer(child)
        else:
            raise ModelError('Unsupported child element')
1186730
def add_section(self, section):
        
        self._sections = self._ensure_append(section, self._sections)