// SetDirty is normally used to indicate that a cell has
// been displayed (in which case dirty is false), or to manually
// force a cell to be marked dirty.
326580
func (cb *CellBuffer) SetDirty(x, y int, dirty bool) {
	if x >= 0 && y >= 0 && x < cb.w && y < cb.h {
		c := &cb.cells[(y*cb.w)+x]
		if dirty {
			c.lastMain = rune(0)
		} else {
			if c.currMain == rune(0) {
				c.currMain = ' '
			}
			c.lastMain = c.currMain
			c.lastComb = c.currComb
			c.lastStyle = c.currStyle
		}
	}
}
388242
func (t Term) SetDifference(args ...interface{}) Term {
	return constructMethodTerm(t, "SetDifference", p.Term_SET_DIFFERENCE, args, map[string]interface{}{})
}
866157
func (s *TrustedAdvisorCheckSummary) SetCheckId(v string) *TrustedAdvisorCheckSummary {
	s.CheckId = &v
	return s
}
509295
func (ctx *Context) SetBlocky(i bool) error {
	if minor < 2 {
		return ErrorNotImplemented42
	}
	n := 0
	if i {
		n = 1
	}
	return setOption(ctx, C.ZMQ_BLOCKY, n)
}
773643
func (s *DeleteInventoryOutput) SetDeletionSummary(v *InventoryDeletionSummary) *DeleteInventoryOutput {
	s.DeletionSummary = v
	return s
}
603831
func (s *SearchInput) SetSortBy(v string) *SearchInput {
	s.SortBy = &v
	return s
}
310663
func (as *Step) SetSummary(value string) bool {
	if as.hasSummary {
		if as.Text[0] == value {
			return false
		}

		as.Text[0] = value
	} else {
		as.Text = append(as.Text, "")
		copy(as.Text[1:], as.Text)
		as.Text[0] = value
		as.hasSummary = true
	}
	return true
}
688996
func SetCell(x, y int, ch rune, fg, bg Attribute) {
	st := mkStyle(fg, bg)
	screen.SetContent(x, y, ch, nil, st)
}
628832
func (df *DirtyFile) SetBlockSyncing(
	ctx context.Context, ptr BlockPointer) error {
	df.lock.Lock()
	defer df.lock.Unlock()
	state := df.fileBlockStates[ptr]
	if state.copy == blockNeedsCopy {
		return fmt.Errorf("Trying to sync a block that isn't dirty: %v", ptr)
	}
	state.copy = blockNeedsCopy
	state.sync = blockSyncing
	block, err := df.dirtyBcache.Get(ctx, df.Path.Tlf, ptr, df.Path.Branch)
	if err != nil {
		// The dirty block cache must always contain the dirty block
		// until the full sync is completely done.  If the block is
		// gone before we have even finished syncing it, that is a
		// fatal bug, because no one would be able to read the dirtied
		// version of the block.
		panic(err)
	}
	fblock, ok := block.(*FileBlock)
	if !ok {
		panic("Dirty file syncing a non-file block")
	}
	state.syncSize = int64(len(fblock.Contents))
	df.totalSyncBytes += state.syncSize
	df.notYetSyncingBytes -= state.syncSize
	df.fileBlockStates[ptr] = state
	df.dirtyBcache.UpdateSyncingBytes(df.Path.Tlf, state.syncSize)
	return nil
}
1370689
func (s *UpdateConditionalForwarderInput) SetDirectoryId(v string) *UpdateConditionalForwarderInput {
	s.DirectoryId = &v
	return s
}
464591
func (s *ListTransformJobsInput) SetSortBy(v string) *ListTransformJobsInput {
	s.SortBy = &v
	return s
}
92843
func (self *AttributeImpl) markDirty() {
	//no sense marking something dirty twice
	if self.dirty() {
		return
	}
	self.clean = false

	//all outgoing are reachable for dirtyness
	self.walkOutgoing(func(e *edgeImpl) {
		e.dest().markDirty()
	})

	if DEBUG_MESSAGES {
		print("mark dirty ---", self.name, "is eager?", self.nType == EAGER)
	}
	if self.nType == EAGER {
		eagerQueue = append(eagerQueue, self)
	}
}
100948
func (s *ListWorkteamsInput) SetSortBy(v string) *ListWorkteamsInput {
	s.SortBy = &v
	return s
}
277755
func (s *ListLabelingJobsInput) SetSortBy(v string) *ListLabelingJobsInput {
	s.SortBy = &v
	return s
}
885444
func (s *ListEndpointsInput) SetSortBy(v string) *ListEndpointsInput {
	s.SortBy = &v
	return s
}
763114
func SetBlocky(i bool) error {
	if initVersionError != nil {
		return initVersionError
	}
	if initContextError != nil {
		return initContextError
	}
	return defaultCtx.SetBlocky(i)
}
744419
func (s *ListHyperParameterTuningJobsInput) SetSortBy(v string) *ListHyperParameterTuningJobsInput {
	s.SortBy = &v
	return s
}