Create an Acl definition
 @param value [Hash] Acl definition, ID field is mandatory
 @param options [Hash] options parameter hash
 @return [Hash] The result Acl
358733
def create(value, options = {})
      custom_params = use_cas(@options)
      @raw = send_put_request(@conn, ['/v1/acl/create'], options, value, custom_params)
      parse_body
    end
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 || [];
}
1135488
function (name, value) {
			var options = this.options;

			if (value === void 0) {
				return options[name];
			} else {
				options[name] = value;
			}
		}
354287
public void setAcl(final String path, final List<ACL> acl) throws ZkException {
        if (path == null) {
            throw new NullPointerException("Missing value for path");
        }

        if (acl == null || acl.size() == 0) {
            throw new NullPointerException("Missing value for ACL");
        }

        if (!exists(path)) {
            throw new RuntimeException("trying to set acls on non existing node " + path);
        }

        retryUntilConnected(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                Stat stat = new Stat();
                _connection.readData(path, stat, false);
                _connection.setAcl(path, acl, stat.getAversion());
                return null;
            }
        });
    }
993347
public static ArrayList<ACL> createAcl(FailoverWatcher failoverWatcher, String znode) {
    if (znode.equals("/chronos")) {
      return Ids.OPEN_ACL_UNSAFE;
    }
    
    if (failoverWatcher.isZkSecure()) {
      ArrayList<ACL> acls = new ArrayList<ACL>();
      acls.add(new ACL(ZooDefs.Perms.READ, ZooDefs.Ids.ANYONE_ID_UNSAFE));
      acls.add(new ACL(ZooDefs.Perms.ALL, new Id("sasl", failoverWatcher.getZkAdmin())));
      return acls;
    } else {
      return Ids.OPEN_ACL_UNSAFE;
    }
  }
857249
def create(options = {})
      query = { 
        query: {
          username: options[:username],
          password: options[:password],
          attributes: hash_to_base64_json(options[:attributes])
          }
        }
      new_options = default_options_to_merge_with.merge(query)
      self.class.post("/#{@api_ver}/users", new_options)
    end
532906
def set(option, value=(not_set=true), ignore_setter=false, &block)
      raise ArgumentError, 'value not set' if block and !not_set
      return self if !not_set and value.nil?

      if not_set
        set_options option
        return self
      end

      if respond_to?("#{option}=") and not ignore_setter
        return __send__("#{option}=", value)
      end

      define_accessors option, value
      self
    end
15398
def acls
      acls = []
      response = client.get("#{@api_end_point}#{self.id}/acls") rescue nil
      if response
        response['data'].each do |attributes|
          acls << Kong::Acl.new(attributes)
        end
      end
      acls
    end
572520
def update(value, options = {})
      raise Diplomat::IdParameterRequired unless value['ID'] || value[:ID]

      custom_params = use_cas(@options)
      @raw = send_put_request(@conn, ['/v1/acl/update'], options, value, custom_params)
      parse_body
    end
649805
def create(self, acl=None):
        ''''''
        parent, name = getParentAndBase(self.path)
        json = { 'name': name }
        if acl is not None:
            json['acl'] = acl.to_api_param()
        response = self.client.postJsonHelper(DataDirectory._getUrl(parent), json, False)
        if (response.status_code != 200):
            raise DataApiError("Directory creation failed: " + str(response.content))
838401
function(acl) {
                var args = {
                    url: this.buildUri(this.type, this.id),
                    method: corbel.request.method.PUT,
                    data: acl,
                    Accept: 'application/corbel.acl+json'
                };

                return this.request(args);
            }
667627
def []=(flag, value)
      if o = option(flag)
        o.value = value
      else
        raise ArgumentError, "no option with flag `#{flag}'"
      end
    end
451087
def options=(options)
      fail ArgumentError, 'options must be a Hash. ' \
                          "#{ options.inspect } given." unless options.is_a?(Hash)

      @options.merge! options

      build_query
    end
36205
def rules_ACL_id
      outside_interface_data = self['firewallInterfaces'].find { |interface_data| interface_data['name'] == 'outside' }
      incoming_ACL = outside_interface_data['firewallContextAccessControlLists'].find { |firewallACL_data| firewallACL_data['direction'] == 'in' } if outside_interface_data

      if incoming_ACL
        return incoming_ACL['id']
      else
        return nil
      end
    end
877427
def set(key, value)
      UI.crash!("Key '#{key}' must be a symbol. Example :#{key}.") unless key.kind_of?(Symbol)
      option = option_for_key(key)

      unless option
        UI.user_error!("Could not find option '#{key}' in the list of available options: #{@available_options.collect(&:key).join(', ')}")
      end

      option.verify!(value)

      @values[key] = value
      true
    end
846551
public void setACL(ACL acl){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.SetACL);

        SetACLProtocol p = new SetACLProtocol(acl);

        connection.submitRequest(header, p, null);
    }
284053
public static ACL parseAcl(String aclString) {
        String[] aclComponents = getComponents(aclString, "acl", "scheme:id");
        return new ACL(ZooDefs.Perms.ALL, new Id(aclComponents[0], aclComponents[1]));
    }