Calls initValuesImpl on the super class. If the returned value is already in the list of
values initValuesImpl is called again. This happens up to 10000 times. If a new value is
found it is stored in the set.
974914
@Override
	protected String initValuesImpl(final FieldCase ca) {
		if (ca == FieldCase.NULL || ca == FieldCase.BLANK) {
			return null;
		}
		String s = super.initValuesImpl(ca);
		int counter = 10000;
		while (set.contains(s) && counter > 0) {
			s = super.initValuesImpl(ca);
			counter--;
		}
		if (counter == 0) {
			throw new IllegalStateException("Could not generate unique value");
		}
		set.add(s);
		return s;
	}
319210
public final void set(int i, int newValue) {
        if (fullWidth) {
            array.set(i, newValue);
            return;
        }

        boolean success = false;
        int index = getIndex(i);
        int subIndex = getSubIndex(i);
        while (!success) {
            int prev = array.get(index);
            int next = pack(prev, newValue, subIndex);
            success = array.compareAndSet(index, prev, next);
        }
    }
1051788
def postinit(self, dest=None, values=None):
        
        self.dest = dest
        self.values = values
575497
protected void initObject() {

        Object o;

        if (CmsStringUtil.isEmpty(getParamAction()) || CmsDialog.DIALOG_INITIAL.equals(getParamAction())) {
            // this is the initial dialog call
            o = new ArrayList();
            ((List)o).add("/");
        } else {
            // this is not the initial call, get module from session
            o = getDialogObject();
        }

        if (!(o instanceof List)) {
            m_resources = new ArrayList();
            m_resources.add("/");
        } else {
            // reuse object stored in session
            m_resources = (List)o;
        }
    }
1263102
protected void setValue(int newPosition, T1 valueSum, long valueN,
      boolean currentExisting) {
    if (valueN > 0) {
      if (currentExisting) {
        newBasicValueSumList[newPosition] = operations
            .add11(newBasicValueSumList[newPosition], valueSum);
        newBasicValueNList[newPosition] += valueN;
      } else {
        newBasicValueSumList[newPosition] = valueSum;
        newBasicValueNList[newPosition] = valueN;
      }
    }
  }
1321418
def _set_initial(self, initial):
        
        super(Select, self)._set_initial(initial)
        if not self._value and self.options:
            self.value = self.options[0]
322123
private function initProphecyReturnValues() {
		$reflection = new \Maybe\Util\Reflection($this->classname);
		
		$returnTypes = $reflection->getReturnTypes();
		foreach ($returnTypes as $method => $type) {
			$this->initProphecyReturnValueForMethod($method, $type);
		}
	}
1354109
private void newValueOnTOS() {
        IsNullValueFrame frame = getFrame();
        if (frame.getStackDepth() < 1) {
            return;
        }
        int tosSlot = frame.getNumSlots() - 1;
        IsNullValue tos = frame.getValue(tosSlot);
        if (tos.isDefinitelyNull()) {
            slotContainingNewNullValue = tosSlot;
        }
        if (trackValueNumbers) {
            try {
                ValueNumberFrame vnaFrameAfter = vnaDataflow.getFactAfterLocation(getLocation());
                if (vnaFrameAfter.isValid()) {
                    ValueNumber tosVN = vnaFrameAfter.getTopValue();
                    getFrame().setKnownValue(tosVN, tos);
                }
            } catch (DataflowAnalysisException e) {
                AnalysisContext.logError("error", e);
            }
        }
    }
1261503
private void initialize()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "initialize");
        
    subsets = new ReliabilitySubset[maxReliabilityIndex + 1];
    subsetIDs = new long[maxReliabilityIndex + 1];
    for(int i=0;i<subsetIDs.length;i++)
    {
      subsetIDs[i] = NO_ID;             
    }
    
    createControlAdapter(); 
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "initialize");
  }
402874
def postinit(self, value=None, slice=None):
        
        self.value = value
        self.slice = slice
605067
private function initialize()
    {
        if ($this->callable !== null) {
            // $func will be $adapter->fetchObjectFromCache();
            $func                      = $this->callable;
            $result                    = $func();
            $this->hasValue            = $result[0];
            $this->value               = $result[1];
            $this->prevTags            = isset($result[2]) ? $result[2] : [];
            $this->expirationTimestamp = null;

            if (isset($result[3]) && is_int($result[3])) {
                $this->expirationTimestamp = $result[3];
            }

            $this->callable = null;
        }
    }
360066
def initialize_values( initial_values, results_hash )
      h = {}
      if initial_values && !initial_values.empty?
        initial_values.each do |k,v|
          h[k.to_s] = v
        end
      end
      
      IR.find_values( results_hash ).each do |i|
        if !i.empty?
          i.each do |k,v|
            h[k.to_s] = v
          end           
        end
      end
      
      h
    end
345587
private function _initialize()
    {
        if ($this->getInitialized()) {
            return;
        }

        $params = $this->getParameters();
        if ($params !== null) {
            foreach ($params as $param) {
                if ('in' == $param->getName()) {
                    $this->setInputEncoding($param->getValue());
                } else {
                    if ('out' == $param->getName()) {
                        $this->setOutputEncoding($param->getValue());
                    }
                }
            }
        }

        $this->setInitialized(true);
    }
477421
def initialized(self, value):
        

        if value is not None:
            assert type(value) is bool, "'{0}' attribute: '{1}' type is not 'bool'!".format("initialized", value)
        self.__initialized = value
1172403
public void postInitialize() throws ContradictionException {
        final int[] biggest = new int[prop.nbDims];
        for (int i = 0; i < prop.bins.length; i++) {
            for (int d = 0; d < prop.nbDims; d++) {
                biggest[d] = Math.max(biggest[d], prop.iSizes[d][i]);
            }
            if (!prop.bins[i].isInstantiated()) {
                final DisposableValueIterator it = prop.bins[i].getValueIterator(true);
                try {
                    while (it.hasNext()) {
                        candidate.get(it.next()).set(i);
                    }
                } finally {
                    it.dispose();
                }
            }
        }

        for (int b = 0; b < prop.nbBins; b++) {
            for (int d = 0; d < prop.nbDims; d++) {
                dynBiggest[d][b] =
                        prop.getVars()[0].getEnvironment().makeInt(biggest[d]);
            }
        }

        fullKnapsack();
    }
8651
private function checkCallConstraints(): void
    {
        if ($this->alreadyConstructed) {
            throw new ImmutabilityViolationException(\sprintf(
                'Class %s constructor was already called',
                static::class
            ));
        }

        $stack = \debug_backtrace();
        while (\count($stack) > 0 && $stack[0]['function'] !== 'checkImmutability') {
            \array_shift($stack);
        }

        if (!isset($stack[1]) || $stack[1]['function'] !== '__construct') {
            throw new ImmutabilityViolationException(\sprintf(
                'Immutability check can only be called from constructor, called from %s::%s',
                static::class,
                $stack[1]['function']
            ));
        }

        $this->alreadyConstructed = true;
    }
1330725
function () {
            this.$DropDownTextInput._checkCfgConsistency.call(this);
            var opt = this._cfg.options;
            var values = [];
            var dupValues = [];
            var map = {};

            for (var count = 0; count < opt.length; count++) {
                if (map[opt[count].value]) {
                    dupValues.push(opt[count].value);
                } else {
                    map[opt[count].value] = true;
                    values.push(opt[count]);
                }
            }
            if (dupValues.length > 0) {
                this.controller.setListOptions(values);
                this.$logError(this.DUPLICATE_VALUE, [dupValues]);
            }

        }