Package Torello.HTML

Enum AUM

java.lang.Object

java.lang.Enum<AUM>

Torello.HTML.AUM

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<AUM>

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

AUM (Attribute Update Mode) - Documentation.

AUM: Attribute Update Mode

Used in conjunction with the methods in class: Attributes
This Java Enumerated Type is used 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)

Hi-Lited Source-Code:

• View Here: Torello/HTML/AUM.java
• Open New Browser-Tab: Torello/HTML/AUM.java

File Size: 31,896 Bytes Line Count: 629 '\n' Characters Found

Enum Constant Summary

Enum Constants

Enum Constant
ConcatToEnd
ConcatToEndAddSpace
ConcatToEndOrSet
ConcatToEndOrSetAddSpace
ConcatToStart
ConcatToStartAddSpace
ConcatToStartOrSet
ConcatToStartOrSetAddSpace
RemoveSubString
RemoveSubString_CI
Replace
Set

Method Summary

Convert String to Enum Constant
Modifier and Type	Method
static AUM	valueOf(String name)
List all Enum Constants
Modifier and Type	Method
static AUM[]	values()
More Methods
Modifier and Type	Method
TagNode	update(TagNode tn, String innerTag, String innerTagValue, SD quote)

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:

 // String cur = tn.AV(innerTag);   int i;
 case Set:  return tn.setAV(innerTag, innerTagValue, quote);

Example:

 // 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:

 // String cur = tn.AV(innerTag);   int i;
 case Replace:  if (cur != null) return tn.setAV(innerTag, innerTagValue, quote);
                return null;

Example:

 // 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:

 // 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:

 // 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:

 // String cur = tn.AV(innerTag);   int i;
 case ConcatToStart:  if (cur != null) return tn.setAV(innerTag, innerTagValue + cur, quote);
                      return null;

Example:

 // 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:

 // 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:

 // 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:

 // String cur = tn.AV(innerTag);   int i;
 case ConcatToStartAddSpace:  if (cur != null) return tn.setAV(innerTag, innerTagValue + ' ' + cur, quote);
                              return null;

Example:

 // 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:

 // 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:

 // 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:

 // String cur = tn.AV(innerTag);   int i;
 case ConcatToEnd:  if (cur != null) return tn.setAV(innerTag, cur + innerTagValue, quote);
                    return null;

Example:

 // 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:

 // 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:

 // 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'>");
 TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
 // newTN.str             ==> <IMG SRC='img-123.jpg' alt='Larry - 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:

 // String cur = tn.AV(innerTag);   int i;
 case ConcatToEndAddSpace:
      if (cur != null) return tn.setAV(innerTag, cur + ' ' + innerTagValue, quote);
      return null;

Example:

 // 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:

 // 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:

 // 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'>");
 TagNode  newTN           = mode.update(tn, innerTag, innerTagValue, SD.SingleQuote);
 // newTN.str             ==> <IMG SRC='img-123.jpg' alt='Bob - 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:

 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) && ((i = cur.indexOf(innerTagValue)) != -1))
             return tn.setAV(innerTag, cur.replace(innerTagValue, ""), quote);

         return null;

     case RemoveSubString_CI:

         if ((cur != null) && ((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 UnreachableError();
 }