Sets the attribute_prefix of this CatalogQueryPrefix.
        The desired prefix of the search attribute value.

        :param attribute_prefix: The attribute_prefix of this CatalogQueryPrefix.
        :type: str
774362
def attribute_prefix(self, attribute_prefix):
        

        if attribute_prefix is None:
            raise ValueError("Invalid value for `attribute_prefix`, must not be `None`")
        if len(attribute_prefix) < 1:
            raise ValueError("Invalid value for `attribute_prefix`, length must be greater than or equal to `1`")

        self._attribute_prefix = attribute_prefix
636797
def set_root_prefix(self, prefix=None):
        
        if prefix:
            self.ROOT_PREFIX = prefix
        else:
            # Find some conda instance, and then use info to get 'root_prefix'
            worker = self._call_and_parse(['info', '--json'], abspath=False)
            info = worker.communicate()[0]
            self.ROOT_PREFIX = info['root_prefix']
853070
public Attribute getAttributeWithPrefix(CharSequence prefix, CharSequence name) {
		for (Attribute attr : event.attributes)
			if (attr.localName.equals(name) && attr.namespacePrefix.equals(prefix))
				return attr;
		return null;
	}
1194702
def _get_prefixes(self, metric_type):
        
        prefixes = []
        if self._prepend_metric_type:
            prefixes.append(self.METRIC_TYPES[metric_type])
        return prefixes
1327212
public void setPrefixConfig(final PrefixConfig config) {
		lock.writeLock().lock();
		try {
			if (config == null) {
				prefixes = EmptyPrefix.INSTANCE;
			} else {
				prefixes = config;
			}
		} finally {
			lock.writeLock().unlock();
		}
	}
453733
def set_attributes(self, attributes):
        
        # pylint: disable=no-member
        for attribute in attributes:
            if attribute.name in self.attributes:
                set_att_def_value(self.attributes[attribute.name], attribute.value, attribute.name, self.name)
                try:
                    set_att_def_value(self.attributes[attribute.name], attribute.value, attribute.name, self.name)
                except TypeError as terr:
                    six.print_("Error while trying to set value of attribute {0} to {1} in " \
                          "parameter {2}" \
                          "".format(attribute.name, attribute.value, self.name))
                    raise terr
            elif attribute.name in self.qualifiers:
                set_att_def_value(self.qualifiers[attribute.name], attribute.value, attribute.name, self.name)
                try:
                    set_att_def_value(self.qualifiers[attribute.name], attribute.value, attribute.name, self.name)
                except TypeError as terr:
                    six.print_("Error while trying to set value of qualifier {0} to " \
                               "{1} in parameter {2}".format(attribute.name,
                                                             attribute.value,
                                                             self.name))
                    raise terr
            else:
                raise UnknownAcdPropertyException(attribute.name,
                                                  attribute.value, self.name)
1217138
def SetKeyPathPrefix(self, key_path_prefix):
    
    self._key_path_prefix = key_path_prefix
    self._key_path_prefix_length = len(key_path_prefix)
    self._key_path_prefix_upper = key_path_prefix.upper()
651867
@Override
    public void setPrefix(String prefix, String uri)
        throws XMLStreamException
    {
        if (prefix == null) {
            throw new NullPointerException("Can not pass null 'prefix' value");
        }
        // Are we actually trying to set the default namespace?
        if (prefix.length() == 0) {
            setDefaultNamespace(uri);
            return;
        }
        if (uri == null) {
            throw new NullPointerException("Can not pass null 'uri' value");
        }

        /* Let's verify that xml/xmlns are never (mis)declared; as
         * mandated by XML NS specification
         */
        {
            if (prefix.equals("xml")) {
                if (!uri.equals(XMLConstants.XML_NS_URI)) {
                    throwOutputError(ErrorConsts.ERR_NS_REDECL_XML, uri);
                }
            } else if (prefix.equals("xmlns")) { // prefix "xmlns"
                if (!uri.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) {
                    throwOutputError(ErrorConsts.ERR_NS_REDECL_XMLNS, uri);
                }
                // At any rate; we are NOT to output it
                return;
            } else {
                // Neither of prefixes.. but how about URIs?
                if (uri.equals(XMLConstants.XML_NS_URI)) {
                    throwOutputError(ErrorConsts.ERR_NS_REDECL_XML_URI, prefix);
                } else if (uri.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) {
                    throwOutputError(ErrorConsts.ERR_NS_REDECL_XMLNS_URI, prefix);
                }
            }
        }

        if (mSuggestedPrefixes == null) {
            mSuggestedPrefixes = new HashMap<String,String>(16);
        }
        mSuggestedPrefixes.put(uri, prefix);

    }
679742
def _parse_prefix_query(self, query_str):
        
        sp = smart_parsing.PrefixSmartParser()
        query = sp.parse(query_str)
        return query
657163
def prefix_attr_add(arg, opts, shell_opts):
    

    spec = { 'prefix': arg }
    v = get_vrf(opts.get('vrf_rt'), abort=True)
    spec['vrf_rt'] = v.rt

    res = Prefix.list(spec)
    if len(res) == 0:
        print("Prefix %s not found in %s." % (arg, vrf_format(v)), file=sys.stderr)
        return

    p = res[0]

    for avp in opts.get('extra-attribute', []):
        try:
            key, value = avp.split('=', 1)
        except ValueError:
            print("ERROR: Incorrect extra-attribute: %s. Accepted form: 'key=value'\n" % avp, file=sys.stderr)
            sys.exit(1)

        if key in p.avps:
            print("Unable to add extra-attribute: '%s' already exists." % key, file=sys.stderr)
            sys.exit(1)

        p.avps[key] = value

    try:
        p.save()
    except NipapError as exc:
        print("Could not save prefix changes: %s" % str(exc), file=sys.stderr)
        sys.exit(1)

    print("Prefix %s in %s saved." % (p.display_prefix, vrf_format(p.vrf)))
726466
def set_attributes(self, **attributes):
        

        auto_set = IxeObject.get_auto_set()
        IxeObject.set_auto_set(False)
        for name, value in attributes.items():
            setattr(self, name, value)
        if auto_set:
            self.ix_set()
        IxeObject.set_auto_set(auto_set)
14716
def set_db_application_prefix(prefix, sep=None):
    """"""
    global _APPLICATION_PREFIX, _APPLICATION_SEP
    _APPLICATION_PREFIX = prefix
    if (sep is not None):
        _APPLICATION_SEP = sep
611502
def index(self, prefix):
        
        # Any web domain will be handled by the standard URLField.
        if self.is_external_url_prefix(prefix):
            prefix = 'http'

        for i, urltype in enumerate(self._url_types):
            if urltype.prefix == prefix:
                return i
        return None
1287376
def _set_prefixes(self, conf):
        
        if conf.get('legacy_namespace', 'y') in self.TRUE_VALUES:
            self.count_prefix = 'stats_counts'
            self.count_suffix = ''
            self.gauge_prefix = 'stats.gauges'
            self.timer_prefix = 'stats.timers'
            self.rate_prefix = 'stats'
            self.rate_suffix = ''
        else:
            global_prefix = conf.get('global_prefix', 'stats')
            self.count_prefix = '%s.%s' % (global_prefix,
                                           conf.get('prefix_counter',
                                                    'counters'))
            self.count_suffix = '.count'
            self.gauge_prefix = '%s.%s' % (global_prefix,
                                           conf.get('prefix_gauge', 'gauges'))
            self.timer_prefix = '%s.%s' % (global_prefix,
                                           conf.get('prefix_timer', 'timers'))
            self.rate_prefix = self.count_prefix
            self.rate_suffix = '.rate'
216921
def set_attribute(self, aid, attrib, val, idx='*'):
        
        if aid in self.__attrib_ids:
            elems = self.__attrib_ids[aid]
            if idx == '*':
                for elem in elems:
                    self.__set_attribute(elem, attrib, val)
            elif idx < len(elems):
                elem = elems[idx]
                self.__set_attribute(elem, attrib, val)
151936
def add_attribute(self, attribute_type, attribute_value):
        
        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        return self.tc_requests.add_attribute(
            self.api_type,
            self.api_sub_type,
            self.unique_id,
            attribute_type,
            attribute_value,
            owner=self.owner,
        )
138139
public void setPrefix(String prefix)
  {
    _prefix = prefix;
    
    if (prefix != null)
      _pathPrefix = prefix.replace('.', '/');
  }