Package Torello.HTML

Enum AUM

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<AUM>

    public enum AUM
    extends java.lang.Enum<AUM>
    AUM - Documentation.

    AUM: Attribute Update Mode


    This Java Enumerated Type is to facilitate some functionality for changing HTML Element Attribute Key-Value (Inner-Tag Key-Value) pairs in an aggregate way. This enumerated type does have a method that it exports. This method is used in combination with the class Attributes to easily change, update, and remove Attribute Key-Value pairs from many (or all) TagNode's in an HTML Page-Vector.

    For Instance: the CSS Attribute class='...', or perhaps the alt='Some Alt Text' attribute could be changed in all TagNode's that have them (on an entire web-page), using a single line of code.
    See Also:
    Attributes.update(Vector, AUM, String, String, SD), Attributes.update(Vector, AUM, int, int, String, String, SD), Attributes.update(Vector, AUM, int[], String, String, SD)



    • Enum Constant Summary

      Enum Constants 
      Enum Constant Description
      ConcatToEnd
      ConcatToEnd when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to concatenate the provided attribute-value to an already in place attribute-value at the end of the current attribute-value String.
      ConcatToEndAddSpace
      This AUM enumerated type is precisely identical to the one named ConcatToEnd - except that in the case where the inner-tag value is appended, a space is added immediately before the newly added String-value token.
      ConcatToEndOrSet
      ConcatToEnd when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to concatenate the provided attribute-value to an already in place attribute-value at the end of the current attribute-value String.
      ConcatToEndOrSetAddSpace
      This AUM enumerated type is precisely identical to the one named ConcatToEnd - except that in the case where the inner-tag value is appended, a space is added immediately before the newly added String-value token.
      ConcatToStart
      ConcatToStart when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to concatenate the provided attribute-value to an already in place attribute-value before the beginning of the current attribute-value String.
      ConcatToStartAddSpace
      This AUM enumerated type is precisely identical to the one named ConcatToStart - except that in the case where the inner-tag value is appended, a space is added immediately after the newly added String-value token.
      ConcatToStartOrSet
      ConcatToStart when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to concatenate the provided attribute-value to an already in place attribute-value before the beginning of the current attribute-value String.
      ConcatToStartOrSetAddSpace
      This AUM enumerated type is precisely identical to the one named ConcatToStartOrSet - except that in the case where the inner-tag value is appended (concatenated), a space is added immediately after the newly added String-value token.
      RemoveSubString
      RemoveSubString when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to remove the first copy found of a provided sub-string from the attribute-value whose attribute name matches the provided inner-tag name.
      RemoveSubString_CI
      This performs the exact same routine as AUM.RemoveSubstring, however the text-String comparison ignores case for the alphabetic letters a..z.
      Replace
      Replace when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to replace any attribute key-value pair that the Element contains; however if there is no current key-value pair that has the provided attribute name, then the HTML Element Node should be skipped, and left un-modified.
      Set
      Set, when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to either 1) replace the current attribute-value with the new text-String, or 2) If there is no attribute key-value with the provided inner-tag name, then to create a new attribute for the HTML Element for the provided attribute-key and value and insert this attribute key-value pair into the element.
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method
      TagNode update​(TagNode tn, String innerTag, String innerTagValue, SD quote)
      static AUM valueOf​(String name)
      static AUM[] values()
      • Methods inherited from class java.lang.Enum

        clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf
      • Methods inherited from class java.lang.Object

        getClass, notify, notifyAll, wait, wait, wait
    • Enum Constant Detail

      • Set

        public static final AUM Set
        Set, when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to either 1) replace the current attribute-value with the new text-String, or 2) If there is no attribute key-value with the provided inner-tag name, then to create a new attribute for the HTML Element for the provided attribute-key and value and insert this attribute key-value pair into the element.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
         // String cur = tn.AV(innerTag);   int i;
         case Set:  return tn.setAV(innerTag, innerTagValue, quote);
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
         // Example 1
         String   innerTag        = "target";
         String   innerTagValue   = "_BLANK";
         AUM      mode            = AUM.Set;
         TagNode  tn              = new TagNode("<A HREF='nextIndex.html'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <A HREF='nextIndex.html' target='_BLANK'>
                                  // New 'target' attribute key-value pair inserted into HTML Element
        
         // Example 2
         String   innerTag        = "target";
         String   innerTagValue   = "_BLANK";
         AUM      mode            = AUM.Set;
         TagNode  tn              = new TagNode("<A HREF='nextIndex.html' TARGET='_Self'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <A HREF='nextIndex.html' target='_BLANK'>
                                  // Old 'target' attribute key-value pair is replaced with new value
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • Replace

        public static final AUM Replace
        Replace when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to replace any attribute key-value pair that the Element contains; however if there is no current key-value pair that has the provided attribute name, then the HTML Element Node should be skipped, and left un-modified.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case Replace:  if (cur != null) return tn.setAV(innerTag, innerTagValue, quote);
                        return null;
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
         // Example 1
         String   innerTag        = "style";
         String   innerTagValue   = "color: red;";
         AUM      mode            = AUM.Replace;
         TagNode  tn              = new TagNode("<A HREF='nextIndex.html' STYLE='font-weight: bold;'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <A HREF='nextIndex.html' style='color: red;'>
                                  // Old 'style' attribute key-value pair is replaced with new value  
        
         // Example 2
         String   innerTag        = "style";
         String   innerTagValue   = "color: red;";
         AUM      mode            = AUM.Replace;
         TagNode  tn              = new TagNode("<A HREF='nextIndex.html'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN                 ==> null
                                  // NOTE: HTML Element left unchanged, because it did not actually
                                  //       have a 'style' attribute in the first place. 
                                  //       A return value of 'null' implies this AUM does not result
                                  //       in a replacement or update for the TagNode passed.
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • RemoveSubString

        public static final AUM RemoveSubString
        RemoveSubString when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to remove the first copy found of a provided sub-string from the attribute-value whose attribute name matches the provided inner-tag name.

        For Instance: If AUM.RemoveSubString were used with an HTML Element that looked like:
        <DIV CLASS='MyClass MyPage Corporation123'>


        Where: innerTag = "CLASS" and innerTagValue = "Corporation123"

        Then: The HTML Element would be updated to:
        <DIV CLASS='MyClass MyPage '>


        NOTE: This uses Java's String.indexOf(...) method, and will only remove the first-instance of the substring.

        ALSO: There is a remaining 'extra-space' that was not removed along with the 'corporation123' String. Keep in mind white-space when using java to modify text.


        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
        5
         // String cur = tn.AV(innerTag);   int i;
         case RemoveSubString:  if (cur != null) if ((i = cur.indexOf(innerTagValue)) != -1)
                                    return tn.setAV(innerTag, cur.replace(innerTagValue, ""), quote);
                                return null;
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • RemoveSubString_CI

        public static final AUM RemoveSubString_CI
        This performs the exact same routine as AUM.RemoveSubstring, however the text-String comparison ignores case for the alphabetic letters a..z. This HTML Element Update Routine, just like the AUM.RemoveSubstring, also only removes the first instance found of the provided substring.

        For Instance: If AUM.RemoveSubString_CI were used with an HTML Element that looked like:
        <DIV CLASS='MyClass MyPage Corporation123' STYLE='FONT-WEIGHT: BOLD; COLOR: RED;'>


        Where: innerTag = "STYLE" and innerTagValue = "color: red;"

        Then: The HTML Element would be updated to:
        <DIV CLASS='MyClass MyPage Corporation123'STYLE='FONT-WEIGHT: BOLD; '>


        NOTE: This uses java's StrCmpr.indexOfIgnoreCase(...) method, and will only remove the first-instance of the substring (ignoring case). In the original HTML Element, the words 'COLOR' and 'RED' were capitalized. Using this 'Case-Insensitive' removal, the user can catch any version. This, fortunately, is how CSS 'Style' Attributes work!

        ALSO: There is a remaining 'extra-space' that was not removed along with the 'corporation123' string. Keep in mind white-space when using java to modify text.


        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
        5
         // String cur = tn.AV(innerTag);   int i;
         case RemoveSubString_CI:  if (cur != null) if ((i = StrCmpr.indexOfIgnoreCase(cur, innerTagValue)) != -1)
                                       return tn.setAV(innerTag, cur.substring(0, i) + cur.substring(i + innerTagValue.length()), quote);
                                   return null;
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • ConcatToStart

        public static final AUM ConcatToStart
        ConcatToStart when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to concatenate the provided attribute-value to an already in place attribute-value before the beginning of the current attribute-value String. However if there is no current key-value pair that has the provided attribute name, then the HTML Element Node should be skipped, and left un-modified.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case ConcatToStart:  if (cur != null) return tn.setAV(innerTag, innerTagValue + cur, quote);
                              return null;
         
        



        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
         // Example 1
         String   innerTag        = "id";
         String   innerTagValue   = "JAVA-AUM-";
         AUM      mode            = AUM.ConcatToStart;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ID='MyPage'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' id='JAVA-AUM-MyPage'>
        
         // Example 2
         String   innerTag        = "id";
         String   innerTagValue   = "JAVA-AUM-";
         AUM      mode            = AUM.ConcatToStart;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN                 ==> null
                                  // NOTE: HTML Element left unchanged, because it did not actually
                                  //       have an 'id' attribute in the first place. 
                                  //       A return value of 'null' implies this AUM does not result
                                  //       in a replacement or update for the TagNode passed.
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • ConcatToStartOrSet

        public static final AUM ConcatToStartOrSet
        ConcatToStart when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to concatenate the provided attribute-value to an already in place attribute-value before the beginning of the current attribute-value String. If there is no current key-value pair that has the provided attribute name, a new Inner-Tag key-value pair should be added to the HTML Element Node using the provided key-String and value-String.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case ConcatToStartOrSet:  if (cur != null) return tn.setAV(innerTag, innerTagValue + cur, quote);
                                   return tn.setAV(innerTag, innerTagValue, quote);
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
         // Example 1
         String   innerTag        = "alt";
         String   innerTagValue   = "This is a personal photo.";
         AUM      mode            = AUM.ConcatToStartOrSet;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='This is a personal photo.'>  
                                  // The original TagNode did not have an 'alt' Inner-Tag, but
                                  // because this AUM has the "OrSet" requirement, when a TagNode
                                  // that's lacking the requested Inner-Tag, the AUM.update method
                                  // will not return null, but instead create a new attribute
                                  // key-value pair, and set the value to the requested parameter.
        
         // Example 2
         String   innerTag        = "alt";
         String   innerTagValue   = "This is a personal photo.";
         AUM      mode            = AUM.ConcatToStartOrSet;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ALT='Bob Wilson'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='This is a personal photo.Bob Wilson'> 
                                  // NOTE: There is no space between the period, and the beginning of the
                                  //       next sentence in the ALT Inner-Tag above! 
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • ConcatToStartAddSpace

        public static final AUM ConcatToStartAddSpace
        This AUM enumerated type is precisely identical to the one named ConcatToStart - except that in the case where the inner-tag value is appended, a space is added immediately after the newly added String-value token.

        NOTE: The primary reason for adding this surprisingly subtle and minor difference is to remind users that keeping up with spaces when tweaking HTML inner-tags can be a bug source.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case ConcatToStartAddSpace:  if (cur != null) return tn.setAV(innerTag, innerTagValue + ' ' + cur, quote);
                                      return null;
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
         // Example 1
         String   innerTag        = "id";
         String   innerTagValue   = "JAVA-AUM";
         AUM      mode            = AUM.ConcatToStartAddSpace;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ID='MyPage'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' id='JAVA-AUM MyPage'>
        
         // Example 2
         String   innerTag        = "id";
         String   innerTagValue   = "JAVA-AUM";
         AUM      mode            = AUM.ConcatToStartAddSpace;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN                 ==> null
                                  // NOTE: HTML Element left unchanged, because it did not actually
                                  //       have an 'id' attribute in the first place. 
                                  //       A return value of 'null' implies this AUM does not result
                                  //       in a replacement or update for the TagNode passed.
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • ConcatToStartOrSetAddSpace

        public static final AUM ConcatToStartOrSetAddSpace
        This AUM enumerated type is precisely identical to the one named ConcatToStartOrSet - except that in the case where the inner-tag value is appended (concatenated), a space is added immediately after the newly added String-value token.

        NOTE: If there were no inner-tag key-value pair, and a new one was added - then an extra space would, hopefully this is obvious, then an extra space would not be needed, and therefore it is not added.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case ConcatToStartOrSetAddSpace:  if (cur != null) return tn.setAV(innerTag, innerTagValue + ' ' + cur, quote);
                                           return tn.setAV(innerTag, innerTagValue, quote);
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         // Example 1
         String   innerTag        = "alt";
         String   innerTagValue   = "This is a personal photo.";
         AUM      mode            = AUM.ConcatToStartOrSetAddSpace;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ALT='Company XYZ'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='This is a personal photo. Company XYZ'>  
        
         // Example 2
         String   innerTag        = "alt";
         String   innerTagValue   = "This is a personal photo.";
         AUM      mode            = AUM.ConcatToStartOrSetAddSpace;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='This is a personal photo.'>  
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • ConcatToEnd

        public static final AUM ConcatToEnd
        ConcatToEnd when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to concatenate the provided attribute-value to an already in place attribute-value at the end of the current attribute-value String. However if there is no current key-value pair that has the provided attribute name, then the HTML Element Node should be skipped, and left un-modified.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case ConcatToEnd:  if (cur != null) return tn.setAV(innerTag, cur + innerTagValue, quote);
                            return null;
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
         // Example 1
         String   innerTag        = "alt";
         String   innerTagValue   = "Photo of Friends";
         AUM      mode            = AUM.ConcatToEnd;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ID='MyPage'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN                 ==> null
                                  // NOTE: HTML Element left unchanged, because it did not actually
                                  //       have an 'alt' attribute in the first place. 
                                  //       A return value of 'null' implies this AUM does not result
                                  //       in a replacement or update for the TagNode passed.
        
         // Example 2
         String   innerTag        = "alt";
         String   innerTagValue   = " - Photo of Friends";
         AUM      mode            = AUM.ConcatToEnd;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ALT='Bob Wilson'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='Bob Wilson - Photo of Friends'> 
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • ConcatToEndOrSet

        public static final AUM ConcatToEndOrSet
        ConcatToEnd when used as an Attribute Update Method, tells the HTML Element Attribute Update Logic to concatenate the provided attribute-value to an already in place attribute-value at the end of the current attribute-value String. If there is no current key-value pair that has the provided attribute name, a new Inner-Tag key-value pair should be added to the HTML Element Node using the provided key-String and value-String.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case ConcatToEndOrSet:  if (cur != null) return tn.setAV(innerTag, cur + innerTagValue, quote);
                                 return tn.setAV(innerTag, innerTagValue, quote);
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
         // Example 1
         String   innerTag        = "alt";
         String   innerTagValue   = "This is a personal photo.";
         AUM      mode            = AUM.ConcatToEndOrSet;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ALT='Larry at Work.'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='Larry at Work.This is a personal photo.'>
                                  // NOTE: There is no space between the period, and the beginning of the
                                  //       next sentence in the ALT Inner-Tag above!  
        
         // Example 2
         String   innerTag        = "alt";
         String   innerTagValue   = "This is a personal photo.";
         AUM      mode            = AUM.ConcatToEndOrSet;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='This is a personal photo.'>
                                  // The original TagNode did not have an 'alt' Inner-Tag, but
                                  // because this AUM has the "OrSet" requirement, when a TagNode
                                  // that's lacking the requested Inner-Tag, the AUM.update method
                                  // will not return null, but instead create a new attribute
                                  // key-value pair, and set the value to the requested parameter.
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • ConcatToEndAddSpace

        public static final AUM ConcatToEndAddSpace
        This AUM enumerated type is precisely identical to the one named ConcatToEnd - except that in the case where the inner-tag value is appended, a space is added immediately before the newly added String-value token.

        NOTE: The primary reason for adding this surprisingly subtle and minor difference is to remind users that keeping up with spaces when tweaking HTML inner-tags can be a bug source.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case ConcatToEndAddSpace:  if (cur != null) return tn.setAV(innerTag, cur + ' ' + innerTagValue, quote);
                                    return null;
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
         // Example 1
         String   innerTag        = "id";
         String   innerTagValue   = "JAVA-AUM-EXAMPLE";
         AUM      mode            = AUM.ConcatToEndAddSpace;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN                 ==> null
                                  // NOTE: HTML Element left unchanged, because it did not actually
                                  //       have an 'id' attribute in the first place. 
                                  //       A return value of 'null' implies this AUM does not result
                                  //       in a replacement or update for the TagNode passed.
        
         // Example 2
         String   innerTag        = "id";
         String   innerTagValue   = "JAVA-AUM-EXAMPLE";
         AUM      mode            = AUM.ConcatToEndAddSpace;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ID='MyClass'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' id='MyClass JAVA-AUM-EXAMPLE'>
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
      • ConcatToEndOrSetAddSpace

        public static final AUM ConcatToEndOrSetAddSpace
        This AUM enumerated type is precisely identical to the one named ConcatToEnd - except that in the case where the inner-tag value is appended, a space is added immediately before the newly added String-value token.

        NOTE: If there were no inner-tag key-value pair, and a new one was added - then an extra space would, hopefully this is obvious, then an extra space would not be needed, and therefore it is not added.

        Here is how the HTML Element Attribute Update is Performed:
        1
        2
        3
        4
         // String cur = tn.AV(innerTag);   int i;
         case ConcatToEndOrSetAddSpace:  if (cur != null) return tn.setAV(innerTag, cur + ' ' + innerTagValue, quote);
                                         return tn.setAV(innerTag, innerTagValue, quote);
         
        


        Example:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         // Example 1
         String   innerTag        = "alt";
         String   innerTagValue   = "This is a corporate photo.";
         AUM      mode            = AUM.ConcatToEndOrSetAddSpace;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='This is a corporate photo.'> 
        
         // Example 2
         String   innerTag        = "alt";
         String   innerTagValue   = "This is a corporate photo.";
         AUM      mode            = AUM.ConcatToEndOrSetAddSpace;
         TagNode  tn              = new TagNode("<IMG SRC='img-123.jpg' ALT='Bob Wilson.'>");
         TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
         // newTN.str             ==> <IMG SRC='img-123.jpg' alt='Bob Wilson. This is a corporate photo.'
         
        
        See Also:
        update(TagNode, String, String, SD), HTMLNode.str
    • Method Detail

      • values

        public static AUM[] values()
        Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
        for (AUM c : AUM.values())
            System.out.println(c);
        
        Returns:
        an array containing the constants of this enum type, in the order they are declared
      • valueOf

        public static AUM valueOf​(java.lang.String name)
        Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
        Parameters:
        name - the name of the enum constant to be returned.
        Returns:
        the enum constant with the specified name
        Throws:
        java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
        java.lang.NullPointerException - if the argument is null
      • update

        public final TagNode update​(TagNode tn,
                                    java.lang.String innerTag,
                                    java.lang.String innerTagValue,
                                    SD quote)
        This performs the Update corresponding to the Attribute-Update-Mode for the particular AUM instance for 'this' enumerated-type object reference.
        Parameters:
        tn - This HTML Element TagNode on which the update shall be performed.
        innerTag - The Inner-Tag Key Name to look for inside the HTML Element.
        innerTagValue - The Inner-Tag Value to update, remove, concatenate, append or set.
        quote - This is a major issue in HTML / Java Programming. The best thing to do is to not try to solve this problem at the lower-level, but rather propagate it up.
        Returns:
        a newly updated or modified TagNode reference object. If the update mode did not permit an attribute removal, update, or addition, then 'null' shall be returned. Again, if 'null' is returned, it means the TagNode did not change - or, rather - did not need to be changed as per the requirements of the chosen Attribute Update Method (AUM).
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
         String cur = tn.AV(innerTag);   int i;
         switch (this)
         {
             case Set:                           return tn.setAV(innerTag, innerTagValue, quote);
        
             case Replace:                       if (cur != null) return tn.setAV(innerTag, innerTagValue, quote);
                                                 return null;
        
             case RemoveSubString:               if (cur != null) if ((i = cur.indexOf(innerTagValue)) != -1)
                                                     return tn.setAV(innerTag, cur.replace(innerTagValue, ""), quote);
                                                 return null;
        
             case RemoveSubString_CI:            if (cur != null) if ((i = StrIndexOf.first_CI(cur, innerTagValue)) != -1)
                                                     return tn.setAV(innerTag, cur.substring(0, i) + cur.substring(i + innerTagValue.length()), quote);
                                                 return null;
        
             case ConcatToStart:                 if (cur != null) return tn.setAV(innerTag, innerTagValue + cur, quote);
                                                 return null;
        
             case ConcatToStartOrSet:            if (cur != null) return tn.setAV(innerTag, innerTagValue + cur, quote);
                                                 return tn.setAV(innerTag, innerTagValue, quote);
        
             case ConcatToStartAddSpace:         if (cur != null) return tn.setAV(innerTag, innerTagValue + ' ' + cur, quote);
                                                 return null;
        
             case ConcatToStartOrSetAddSpace:    if (cur != null) return tn.setAV(innerTag, innerTagValue + ' ' + cur, quote);
                                                 return tn.setAV(innerTag, innerTagValue, quote);
        
             case ConcatToEnd:                   if (cur != null) return tn.setAV(innerTag, cur + innerTagValue, quote);
                                                 return null;
        
             case ConcatToEndOrSet:              if (cur != null) return tn.setAV(innerTag, cur + innerTagValue, quote);
                                                 return tn.setAV(innerTag, innerTagValue, quote);
        
             case ConcatToEndAddSpace:           if (cur != null) return tn.setAV(innerTag, cur + ' ' + innerTagValue, quote);
                                                 return null;
        
             case ConcatToEndOrSetAddSpace:      if (cur != null) return tn.setAV(innerTag, cur + ' ' + innerTagValue, quote);
                                                 return tn.setAV(innerTag, innerTagValue, quote);
        
             default:                            throw new InternalError("This exception should never be thrown, but it was.");
         }