setFullId: setFullId, setBase: setBase, setEncoding: setEncoding, inverse: inverse,
778109
function(input) {

			if (!isFullId && baseCharSet.set == DEFAULT_BASESET)
			{
				input = Utils.getObjectIdTime(input);
			}

			var bitStream = BitStream(String(input), baseCharSet);

			var result = '';
			while (!bitStream.isEOF())
			{
				var value = bitStream.getBits(encodingCharSet.bits);
				var nextChar = encodingCharSet.encode(value);
				if (isInverse)
				{
					result = nextChar + result;
				}
				else
				{
					result += nextChar;
				}
			}

			return result;
		}
671819
function setRelatedTo( $relid, $params=FALSE ) {
    $relation           = array();
    if(( '<' == substr( $relid, 0, 1 )) &&
       ( '>' == substr( $relid, -1 )))
                 $relid = substr( $relid, 1, ( strlen( $relid ) - 2 ));
    $relation['value']  = $relid;
    $relation['params'] = $this->_setParams( $params );
            // remove default
    if( isset( $relation['params']['RELTYPE'] ) &&
       ( strtoupper( $relation['params']['RELTYPE'] ) == 'PARENT' ))
      unset( $relation['params']['RELTYPE'] );
    $this->relatedto[]  = $relation;
  }
622563
def bool_set(operation,*sets):
    ''''''
    if len(sets)<=1:
        return sets
    if operation=='and':
        return and_sets(*sets)
    if operation=='or':
        return or_sets(*sets)
    if operation=='not':
        return not_sets(*sets)
140528
private void encodeRecursive() {
    boolean isExactlyOne = false;
    while (this.currentLiterals.size() > this.k) {
      this.literals.clear();
      this.nextLiterals.clear();
      for (int i = 0; i < this.currentLiterals.size(); i++) {
        this.literals.push(this.currentLiterals.get(i));
        if (i % this.k == this.k - 1 || i == this.currentLiterals.size() - 1) {
          this.encodeNonRecursive(this.literals);
          this.literals.push(this.result.newVariable());
          this.nextLiterals.push(this.literals.back().negate());
          if (isExactlyOne && this.literals.size() > 0)
            this.result.addClause(this.literals);
          for (int j = 0; j < this.literals.size() - 1; j++)
            this.result.addClause(this.literals.back().negate(), this.literals.get(j).negate());
          this.literals.clear();
        }
      }
      this.currentLiterals.replaceInplace(this.nextLiterals);
      isExactlyOne = true;
    }
    this.encodeNonRecursive(this.currentLiterals);
    if (isExactlyOne && this.currentLiterals.size() > 0)
      this.result.addClause(this.currentLiterals);
  }
432675
def p_declnamelist(self, p):
        ''
        p[0] = p[1] + (p[3],)
        p.set_lineno(0, p.lineno(1))
692341
def set(self, oid, typevalue):
		
		success = False
		type_ = typevalue.split()[0]
		value = typevalue.lstrip(type_).strip().strip('"')
		ret_value = self.get_setter(oid)(oid, type_, value)
		if ret_value:
			if ret_value in ErrorValues or ret_value == 'DONE':
				print(ret_value)
			elif ret_value == True:
				print('DONE')
			elif ret_value == False:
				print(Error.NotWritable)
			else:
				raise RuntimeError("wrong return value: %s" % str(ret_value))
		else:	
			print(Error.NotWritable)
171162
def _define(self, key, default=_UNSET, help=_UNSET, validate=_UNSET):
        
        if default is not _UNSET:
            self.setdefault(key, default)
        if help is not _UNSET:
            self.meta_set(key, 'help', help)
        if validate is not _UNSET:
            self.meta_set(key, 'validate', validate)
192813
function(options) {
      var attrs = {};
      for (var key in this.attributes) attrs[key] = void 0;
      return this.set(attrs, _.extend({}, options, {unset: true}));
    }
466727
def booleanize(truthy):
    '''
    
    '''
    if truthy is None:
        return False
    elif isinstance(truthy, basestring):
        if truthy:
            try:
                return bool(distutils.util.strtobool(truthy))
            except ValueError:
                return True
        else:
            return False
    elif is_collection(truthy):
        return not is_empty(truthy)
    else:
        return bool(truthy)
237386
function setValue(descriptor,key,set,update)
        {
          var _descriptor = descriptor,
              _key = key,
              _set = set,
              _update = update,
              _oldValue;
          return function valueSet(v)
          {
            _oldValue = _descriptor.value;
            if(_set(this,_key,v,_oldValue,arguments,this._stopChange))
            {
              _descriptor.value = v;
            }
            if(!this._stopChange)
            {
              _update(this,_key,v,_oldValue,arguments);
            }
            this._stopChange = undefined;
          }
        }
306373
def set_phases(self, literals=[]):
        

        if self.glucose:
            pysolvers.glucose3_setphases(self.glucose, literals)
1121128
def encoded(self):
        

        encoded = {}
        for i in range(len(self.credType.names)):
            self.credType.names[i]
            attr_types = self.credType.attrTypes[i]

            for at in attr_types:
                attrName = at.name
                if attrName in self._vals:
                    if at.encode:
                        encoded[attrName] = encodeAttr(self._vals[attrName])
                    else:
                        encoded[attrName] = self._vals[at.name]
        return encoded
339011
function BaseN(options) {

    var self = this;
    var opt = options || {};

    // assert
    if (opt.max && opt.length) {
        throw new Error('cannot specify both max and length');
    }

    // merge in default options
    for (var key in DEFAULT_OPTIONS) {
        if (!opt.hasOwnProperty(key)) {
            opt[key] = DEFAULT_OPTIONS[key];
        }
    }

    /**
     * a string of all allowed characters used for encoding/decoding.
     * @type {String}
     */
    self.characters = opt.characters;

    /**
     * number of unique characters used to encode ids.
     * @type {Number}
     */
    self.base = opt.base || opt.characters.length;

    /**
     * max length of id string.
     * @type {Number}
     */
    self.length = opt.length || self._findLength(opt.max);
}
776784
def encode(self):
        
        element = ElementTree.Element(self.name)
        element = self._set_nil(element, lambda value: str(value))
        return element
1283919
def _setLearningMode(self, l4Learning = False, l2Learning=False):
    
    for column in self.L4Columns:
      column.setParameter("learn", 0, l4Learning)
    for column in self.L2Columns:
      column.setParameter("learningMode", 0, l2Learning)
1046232
public static <S, I, T> void findCharacterizingSet(UniversalDeterministicAutomaton<S, I, T, ?, ?> automaton,
                                                       Collection<? extends I> inputs,
                                                       Collection<? super Word<I>> result) {
        findIncrementalCharacterizingSet(automaton, inputs, Collections.emptyList(), result);
    }
398694
def p_realdecl(self, p):
        ''
        reallist = [Real(p[1],
                         Width(msb=IntConst('31', lineno=p.lineno(2)),
                               lsb=IntConst('0', lineno=p.lineno(2)),
                               lineno=p.lineno(2)),
                         lineno=p.lineno(2)) for r in p[2]]
        p[0] = Decl(tuple(reallist), lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))