Syntax

   @RemoveAttributes(fme_encoded,<attrName>[,<attrName>]*) 
   @RemoveAttributes(fme_pcre_match[,fme_encoded][,<regexp>]+) 

   Deprecated:
   @RemoveAttributes(fme_regexp_match[,<regexp>]+)

Arguments

   <attrName>  
   
      The names of the attributes being deleted.
   
      Range: String  
      
   <fme_pcre_match>

      A Perl Compatible Regular Expression, used to match the names of the attributes
      being deleted.

      Range: String

   <fme_regexp_match>
   
      A legacy Rogue Wave regular expression that is used to match the names of the attributes 
      being deleted.

      Range: String  


   <fme_encoded>

      A flag that indicates that following arguments are FMEParsableText encoded
      
Description

   This command is used as an attribute filter. All attributes specified in the 
   attribute list are removed from the feature. This can be used to reduce the 
   amount of information stored within a feature. It is also useful for removing 
   undesired components from structures.

   If the attribute name is a list attribute ending with {}, then all the 
   attributes in this list are removed.

   If the first argument is fme_regexp_match, then all following parameters are 
   interpreted as regular expressions (REs) and all attributes that match any of 
   the REs will be removed.

   RE Construction
   ~~~~~~~~~~~~~~~

   The following rules determine one-character REs that match a single 
   character:

      Any character that is not a special character (to be defined) matches 
      itself.

      A backslash (\) followed by any special character matches the literal 
      character itself (i.e., this "escapes" the special character).

      The "special characters" are:

         + * ? . [ ] ^ $

      The period (.) matches any character except the newline (for example, 
      ".umpty" matches either "Humpty" or "Dumpty."

      A set of characters enclosed in brackets ([]) is a one-character RE that 
      matches any of the characters in that set. For example, "[akm]" matches 
      either an "a", "k", or "m". A range of characters can be indicated with a 
      dash. For example, "[a-z]" matches any lowercase letter. However, if the 
      first character of the set is the caret (^), then the RE matches any 
      character except those in the set. It does not match the empty string. For 
      example, [^akm] matches any character except "a", "k", or "m". The caret 
      loses its special meaning if it is not the first character of the set.

   The following rules can be used to build a multi-character RE:

      A one-character RE followed by an asterisk (*) matches zero or more 
      occurrences of the RE. Hence, [a-z]* matches zero or more lowercase 
      characters.

      A one-character RE followed by a plus (+) matches one or more occurrences 
      of the RE. Hence, [a-z]+ matches one or more lowercase characters.

      A question mark (?) is an optional element. The preceding RE can occur 
      zero or once in the string - no more. For example, xy?z matches either xyz 
      or xz.

      The concatenation of REs is an RE that matches the corresponding 
      concatenation of strings. For example, [A-Z][a-z]* matches any capitalized 
      word.

   Finally, the entire regular expression can be anchored to match only the 
   beginning or end of a line:

      If the caret (^) is at the beginning of the RE, then the matched string 
      must be at the beginning of a line.

      If the dollar sign ($) is at the end of the RE, then the matched string 
      must be at the end of the line.