Set the values for Fakeblock on a per ACL and per user basis
@param opts
@constructor
968491
function (opts) {
    opts = opts || {};
    this.name = opts.name || 'unknown';
    this.userId = opts.userId;
    this.userRole = opts.userRole || 'anonymous';
    this.acl = opts.acl || {};
    this.permissions = opts.permissions || [];
}
1300798
public function setOpt($opt)
    {
        if ($this->currentStep > 0) {
            throw new \Exception("setOpt method must be called before exec method.", 1);
        }
        foreach ($opt as $key => $value) {
            $this->userOpt[$key] = $value;
        }
    }
1264503
def _set_opts(self, schema=None, **options):
        
        if schema is not None:
            self.schema(schema)
        for k, v in options.items():
            if v is not None:
                self.option(k, v)
1173440
function setOptName(opt, optKey) {
    var key$ = optKey + '$';
    opts[key$] = opts[key$] || {};
    var name = opt.name || fspath.basename(opt.path);
    while (opts[key$][name]) {
      name = '_' + name;
    }
    opts[key$][name] = opt;
    opt.name = name;
  }
1228002
function setDefault (opts, key, val) {
  if (opts.schema) {
    opts.prompts = opts.schema;
    delete opts.schema;
  }
  const prompts = opts.prompts || (opts.prompts = {});
  if (!prompts[key] || typeof prompts[key] !== 'object') {
    prompts[key] = {
      'type': 'string',
      'default': val
    };
  }
  else {
    prompts[key]['default'] = val;
  }
}
493585
function Block(options) {
  if (!(this instanceof Block))
    return new Block(options);

  AbstractBlock.call(this);

  this.txs = [];

  this._raw = null;
  this._size = -1;
  this._witness = -1;

  if (options)
    this.fromOptions(options);
}
64225
protected void opts(String[] opts) {
        if(opts.length < 1) {
            sendResponse(501, "Missing parameters");
            return;
        }

        String option = opts[0].toUpperCase();

        if(!options.containsKey(option)) {
            sendResponse(501, "No option found");
        } else if(opts.length < 2) {
            sendResponse(200, options.get(option));
        } else {
            options.put(option, opts[1].toUpperCase());
            sendResponse(200, "Option updated");
        }
    }
862066
function Plugin(opts) {
  this.namespace = opts.namespace;
  this._fns = {};
  this.util = _.clone(util);
}
1062546
def process_opts(options)
      if options.key?(:only)
        options[:event] = options.delete(:only)
      elsif options.key?(:except)
        options[:event] = [:set_user, :authentication] - Array(options.delete(:except))
      end
      options
    end
771957
function (values, options, callback) {
            if (values) {
                var _value = null;
                for (var _name in values) {
                    if (values.hasOwnProperty(_name)) {
                        _value = values[_name];
                        if((callback && callback(_value, _name, options))!==false){
                            this.set(_name, _value, options);
                        }
                    }
                }
            }

            return this;
        }
645926
function settings(blocks, opt) {
	var self = {
		blocks : blocks || new type.Factory(function(s) {
			self.blocks = new type.Component([]);
			// read until end of stream
			while(s.availableLength() > 0) {
				self.blocks.obj.push(block().read(s));
			}
		}),
	};
	
	return new type.Component(self, opt);
}
46183
function(opts) {
	opts = opts || {};
	this.root = opts.path;
	this.interval = opts.interval || DEFAULT_INTERVAL;
}
1004556
function setEncryption($userPass = '', $ownerPass = '', $pc = array()) {
    $p = bindec("11000000");

    $options =  array('print'=>4, 'modify'=>8, 'copy'=>16, 'add'=>32);

    foreach($pc as  $k=>$v) {
      if  ($v &&  isset($options[$k])) {
        $p+= $options[$k];
      } else  if  (isset($options[$v])) {
        $p+= $options[$v];
      }
    }

    // implement encryption on the document
    if  ($this->arc4_objnum ==  0) {
      // then the block does not exist already, add it.
      $this->numObj++;
      if  (mb_strlen($ownerPass) == 0) {
        $ownerPass = $userPass;
      }

      $this->o_encryption($this->numObj, 'new', array('user'=>$userPass, 'owner'=>$ownerPass, 'p'=>$p));
    }
  }
1221497
private function setUserOptions($options)
    {
        if (is_array($options)) {
            foreach ($options as $property => $value) {
                $this->$property = $value;
            }
        }
    }
481087
function ProtoSet (defaultValues, opts) {
  var self = this
  self.object = []
  self.sources = []
  self.releases = []
  self.binder = LazyWatcher.call(self, self._update, self._listen, self._unlisten)
  self.binder.value = this.object

  if (opts && opts.nextTick) self.binder.nextTick = true
  if (opts && opts.idle) self.binder.idle = true

  if (defaultValues && defaultValues.length) {
    defaultValues.forEach(function (valueOrObs) {
      if (!~self.sources.indexOf(valueOrObs)) {
        self.sources.push(valueOrObs)
      }
    })
    this._update()
  }
}
17594
function(opts) {
    var self = this
    
    this.opts = opts || {}
    
    this.debug = this.opts.debug || debug
    
    this.providers = this.opts.providers || {}
    this.dns = this.opts.dns || {}

    self.init.apply(self, arguments)
}
1261011
public static void onPreSetBlock(ISetBlockCallback callback, CallbackOption<ISetBlockCallbackPredicate> option)
	{
		preSetBlockRegistry.registerCallback(callback, option);
	}