The dom_processing property.
        
        Args:
            value (string). the property value.
777666
def dom_processing(self, value):
        
        if value == self._defaults['domProcessing'] and 'domProcessing' in self._values:
            del self._values['domProcessing']
        else:
            self._values['domProcessing'] = value
913558
def properties(self, value):
        
        if value == self._defaults['properties'] and 'properties' in self._values:
            del self._values['properties']
        else:
            self._values['properties'] = value
925432
def process_value(name, value):
    
    action = ACTIONS.get(name)
    if not action:
        return value

    if callable(action.type):
        return action.type(value)

    if action.const:
        return bool(int(value))

    return value
1163663
function (value) {
            if (this.slice) return;
            if (value === null || typeof value == "undefined")
                value = "";
            this.trueValue = this.formater ? this.formater.format(value) : value;
            //this.element.trueValue = this.trueValue;
            this.showValue = this.masker ? this.masker.format(this.trueValue).value : this.trueValue;
            this.setShowValue(this.showValue);

            //this.trueValue = value;
            //this.showValue = value;
            //this.setShowValue(this.showValue);
        }
559879
private void processKeyValue(Map<ConfigurationKey, Object> properties, String stringKey, Object value) {
        processKeyValue(properties, stringKey, value, false);
    }
407097
def ver(self, value):
        
        if value == self._defaults['ver'] and 'ver' in self._values:
            del self._values['ver']
        else:
            self._values['ver'] = value
1045385
def process_property(property, value)
      
      value.chomp!

      #If either the property or value are empty (or contain invalid whitespace),
      #abort.
      return if property.empty? and value.empty?
      return if value.sub!(%r/\\\s*\z/, '')

      #Strip any leading/trailing characters.
      property.strip!
      value.strip!

      #Raise an error if we have an invalid property name.
      parse_error if property.empty?

      #Parse ISE's value into a path.
      set_by_path(CGI::unescape(property), unescape_value(value.dup), current_section)

      #And continue processing the property and value.
      property.slice!(0, property.length)
      value.slice!(0, value.length)

      #Return nil.
      nil
    
    end
42353
def attribute(self, value):
        

        if value is not None:
            assert type(value) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                "attribute", value)
        self.__attribute = value
961376
def set_process_ref(self, value):
        
        if not isinstance(value, str):
            raise TypeError("ProcessRef must be set to a String")
        self.__process_ref = value
1007394
def token(self, value):
        
        if value is None:
            self._token = value
            return
        if not isinstance(value, str):
            value = str(value)
        if len(value) > 256:
            raise AttributeError
        self._token = value
1300072
function(elem, value){
    if(typeof value=== 'string'){
      value = _.fixObjStr(value)
    }
    this.$watch(value, function(nvalue, ovalue){
      // remove styleProperty that are no longer in nvalue
      for (var i in ovalue) if (ovalue.hasOwnProperty(i) && !nvalue.hasOwnProperty(i)) {
        dom.css(elem, i, '');
      }
      for(i in nvalue) if(nvalue.hasOwnProperty(i)){
        dom.css(elem, i, nvalue[i]);
      }
    },DEEP_STABLE);
  }
1149264
function(value) {
      // avoid to override the tag properties already set
      if (contains(keys, key)) return
      // check whether this value is an array
      isArr = isArray(value)
      // if the key was never set
      if (!value)
        // set it once on the tag instance
        parent[key] = dom
      // if it was an array and not yet set
      else if (!isArr || isArr && !contains(value, dom)) {
        // add the dom node into the array
        if (isArr)
          value.push(dom)
        else
          parent[key] = [value, dom]
      }
    }
1212552
def _cast(self, value):
        
        if self.type != 'text':
            value = utils.cast(self.TYPES.get(self.type)['cast'], value)
        return value
502656
def data(self, value):
        
        if value == self._defaults['data'] and 'data' in self._values:
            del self._values['data']
        else:
            self._values['data'] = value
660377
def variables(self, value):
        

        if value is not None:
            assert type(value) is dict, "'{0}' attribute: '{1}' type is not 'dict'!".format("variables", value)
            for key, element in value.iteritems():
                assert type(key) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                    "variables", key)
                assert type(element) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                    "variables", element)
        self.__variables = value
1326764
def execution_time(self, value):
        
        if value:
            self._execution_time = parse(value) if isinstance(value, type_check) else value
243969
public void parseRawValue(String value)
   {
      int valueIndex = 0;
      int elementIndex = 0;
      m_elements.clear();
      while (valueIndex < value.length() && elementIndex < m_elements.size())
      {
         int elementLength = m_lengths.get(elementIndex).intValue();
         if (elementIndex > 0)
         {
            m_elements.add(m_separators.get(elementIndex - 1));
         }
         int endIndex = valueIndex + elementLength;
         if (endIndex > value.length())
         {
            endIndex = value.length();
         }
         String element = value.substring(valueIndex, endIndex);
         m_elements.add(element);
         valueIndex += elementLength;
         elementIndex++;
      }
   }