JSON Encoding in PeopleCode

I am a big fan of the JSON.simple Java library. JSON.simple integrates well with PeopleCode. It produces flawless JSON without ugly PeopleCode Java Reflection and is compatible with Java 1.2 (for older tools versions). Yes, the object/array to JSON conversion in JSON.simple is nice, but my real reason for using a JSON library is JSON encoding. I can mock up and string together variable values to produce JSON, but my main problem is escaping strings so that they represent safe JSON data (quotes, etc). I thought the PeopleCode EscapeJavascriptString function would handle this for me, but I discovered that JSON != JavaScript. Certain character sequences, such as \' are valid for JavaScript, but invalid for JSON. After my latest tools and app upgrade, I decided to see what it would take to encode strings for JSON from PeopleCode. Here is what I created:

class JSONEncoder
   method encode(&input As string) Returns string;
   
private
   instance JavaObject &meta_chars_;
   instance JavaObject &unsafe_chars_pattern_;
   instance JavaObject &int_;
   
   method init();
end-class;

method encode
   /+ &input as String +/
   /+ Returns String +/
   
   Local JavaObject &matcher;
   Local string &output = &input;
   Local string &replacement;
   Local string &match;
   Local number &offset = 1;
   
   REM ** Run lazy init if needed;
   REM ** Protects against stateless PeopleCode/Stateful JVM;
   %This.init();
   
   &matcher = &unsafe_chars_pattern_.matcher(CreateJavaObject("java.lang.String", &input));
   
   While &matcher.find()
      &match = &matcher.group();
      
      If (&meta_chars_.containsKey(&match)) Then
         REM ** replace meta characters first;
         &replacement = &meta_chars_.get(&match).toString();
      Else
         REM ** not meta, so convert to a unicode escape sequence;
         &replacement = "\u" | Right("0000" | &int_.toHexString(Code(&match)), 4);
      End-If;
      &output = Replace(&output, &matcher.start() + &offset, (&matcher.end() - &matcher.start()), &replacement);
      
      REM ** move the starting position based on the size of the string after replacement;
      &offset = &offset + Len(&replacement) - (&matcher.end() - &matcher.start());
   End-While;
   
   Return &output;
end-method;

method init
   REM ** None only works on local vars, so get a pointer;
   Local JavaObject &int = &int_;
   
   REM ** if &int has no value, then initialize all JavaObject vars;
   /*
    * JavaObject vars will have no value in two scenarios:
    *
    *   1. First use, never initialized
    *   2. Think time function, global variable, anything that causes state
    *      serialization.
    *
    * The first case is obvious. The second case, however, is not. PeopleSoft
    * allows you to make App Classes Global and Component scoped objects, but
    * not JavaObject variables. By using JavaObject variables in Component and
    * Global scope, you can get into a bit of trouble. Retesting these values
    * on each use ensures they are always initialized. The same will happen if
    * you use a think-time function like Prompt or a Yes/No/Cancel MessageBox.
    */
   If (None(&int)) Then
      REM ** Lazy initialize Integer class;
      &int_ = GetJavaClass("java.lang.Integer");
      
      REM ** Lazy initialize the regular expression;
      REM ** List other unsafe characters;
      &unsafe_chars_pattern_ = GetJavaClass("java.util.regex.Pattern").compile("[\\""\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]");
      
      REM ** Lazy initialize the hashtable;
      &meta_chars_ = CreateJavaObject("java.util.Hashtable");
      
      REM ** setup meta characters;
      &meta_chars_.put(Char(8), "\b");
      &meta_chars_.put(Char(9), "\t");
      &meta_chars_.put(Char(10), "\n");
      &meta_chars_.put(Char(12), "\f");
      &meta_chars_.put(Char(13), "\r");
      &meta_chars_.put("\", "\\");
      &meta_chars_.put("""", "\""");
   End-If;
   
end-method;

I adapted this code from the JavaScript quote function in the json.org JSON2 JavaScript parser. Yes, this solution does still use Java (regular expressions and hexadecimal encoding), but it doesn't require external libraries. See, my real motivation was to eliminate external dependencies. I wanted code I could compile and leave in the database; code that didn't require OS file system modifications; code that would upgrade without impacting PS_HOME, psappsrv.cfg, psconfig.sh, or any other upgraded configuration file.

Why an App Class instead of a FUNCLIB? I originally wrote this code as a FUNCLIB function. Step one of the function would populate the hashtable. This meant for each function call, I would incur the overhead of creating and populating the hashtable. Since I know I will call this function multiple times while constructing a JSON string, I wanted a mechanism to persist the hashtable across function calls. An App Class's private instance variable provides this mechanism. What about Global variables? First, I have NEVER used them. Second, you CAN'T use them with variables of type JavaObject. What about serialization, scoping, and think-time functions with Java? I protect against the "First operand of . is Null" error by lazily initializing the hashtable and the regular expression. A postback will reset the JavaObject to Null, and my lazy initialization code will reinitialize it.