3821c.4384h.patch

src/com/goldencode/p2j/oo/core/ConvCp.java 2021-02-05 11:28:05 +0000
11	11	** 002 CA 20190710 Added LegacyResource annotation. Implemented Equals, NotEquals, IsFalse,
12	12	** IsTrue.
13	13	** 003 IAS 20190923 Added implementation of additional methods
	14	** 004 ME 20210204 Use upper case when looking-up the codepage.
14	15	*/
15	16
16	17	/*
...	...
199	200	{
200	201	return new character(MIME.stream().collect(Collectors.joining(",")));
201	202	}
202		int n = PROGRESS.indexOf(enc.getValue());
	203	int n = PROGRESS.indexOf(enc.getValue().toUpperCase());
203	204	return n < 0 ? enc : new character(MIME.get(n));
204	205	}
205	206

     **
     ** -#- -I- --Date-- -------------------------------Description--------------------------------
     ** 001 ME  20200729 Convert from skeleton (OE12.2).
     **     ME  20210205 Add getter for object array Value.
     ** 002 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
     */
-...
     public interface IobjectArrayHolder
     extends com.goldencode.p2j.oo.lang._BaseObject_
+    {
     	@LegacySignature(returns = "OBJECT", qualified = "Progress.Lang.Object", type = Type.GETTER, name = "Value", extent = -1)
        public object<? extends com.goldencode.p2j.oo.lang._BaseObject_>[] getValue();
        @LegacySignature(returns = "OBJECT", qualified = "Progress.Lang.Object", type = Type.GETTER, name = "Value", parameters =
+       {
           @LegacyParameter(name = "idx", type = "INT64", mode = "INPUT")
        })
        public object<? extends com.goldencode.p2j.oo.lang._BaseObject_> getValue_1(final int64 _idx);
        public object<? extends com.goldencode.p2j.oo.lang._BaseObject_> getValue(final int64 _idx);
        @LegacySignature(returns = "INTEGER", type = Type.LENGTH, name = "Value")
        public abstract integer lengthOfValue();

     ** 004 ME  20200331 Fix constructors, add setters and validate input parameters for get methods.
     **     GES 20200526 Change to match legacy enum implementation.
     ** 005 CA  20210113 Renamed clear() to clear_(), to follow NameConverter's rules.
     **     ME  20210204 The class implements ImemptrHolder.
     ** 006 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
     */
-...
     import com.goldencode.p2j.util.BlockManager.Action;
     import com.goldencode.p2j.util.BlockManager.Condition;
     import com.goldencode.p2j.util.InternalEntry.Type;
     import com.goldencode.p2j.oo.common.support.ImemptrHolder;
     import com.goldencode.p2j.oo.lang.*;
     import java.io.IOException;
-...
      */
     @LegacyResource(resource = "OpenEdge.Core.Memptr")
     @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_PARTIAL)
     public class Memptr extends BaseObject
     public class Memptr extends BaseObject implements ImemptrHolder
+    {
        private logical autoDestroy = TypeFactory.logical();

                       size.assign(0);
                       tableHandle.assign(p1.unwrapTempTable());
                       fieldHandle.assign(p2);
                       fieldHandle.assign(p2.unwrapBufferField());
                    }));
+       }

        @LegacySignature(type = Type.PROPERTY, name = "IteratedArray")
        private object<? extends Array> iteratedArray = TypeFactory.object(Array.class);
        public void __skeleton_oo4gl_openedge_core_collections_ArrayIterator_execute__()
        public void __core_collections_ArrayIterator_execute__()
+       {
           externalProcedure(ArrayIterator.class, ArrayIterator.this, new Block((Body) () ->
+          {
-...
        @LegacySignature(type = Type.CONSTRUCTOR, parameters = {
                 @LegacyParameter(name = "poIteratedArray", type = "OBJECT", qualified = "openedge.core.collections.array", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void __skeleton_oo4gl_openedge_core_collections_ArrayIterator_constructor__(
        public void __core_collections_ArrayIterator_constructor__(
                 final object<? extends Array> _poIteratedArray)
+       {
           object<? extends Array> poIteratedArray = TypeFactory.initInput(_poIteratedArray);

     **     RFB 20191022 Added LegacyResource annotation
     ** 002 CA  20191024 Added method support levels and updated the class support level.
     ** 003 ME  20200730 Update parameter names.
     **     ME  20210205 Change second parameter of put method to longchar.
     ** 004 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
     */
-...
           @LegacyParameter(name = "poValue", type = "LONGCHAR", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public longchar put(final character _poKey, final Text _poValue);
        public longchar put(final character _poKey, final longchar _poValue);
        @LegacySignature(returns = "OBJECT", type = Type.METHOD, name = "Put", qualified = "openedge.core.string", parameters =
+       {

     ** 002 CA  20191024 Added method support levels and updated the class support level.
     ** 003 ME  20200729 Update parameter names to match skeleton.
     ** 004 CA  20210113 Renamed clear() to clear_(), to follow NameConverter's rules.
     ** 005 ME  20210205 Removed getMap method from interface definition, this is FWD specific.
     ** 005 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
     */
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public void removeAll(final object<? extends com.goldencode.p2j.oo.core.collections.Icollection> _poKeys);
        public Map<object, object> getMap();
+    }

     public class LegacyCollection
     extends AbstractTtcollection
+    {
        private Collection<object<? extends _BaseObject_>> objects;
        private List<object<? extends _BaseObject_>> objects;
        public void __core_collections_LegacyCollection_execute__()
+       {
-...
           object<? extends _BaseObject_> p1 = TypeFactory.initInput(_p1);
           return function(this, "Add", logical.class, new Block((Body) () -> {
              returnNormal(p1._isValid() && objects.add(p1));
              returnNormal(add_(p1));
           }));
+       }
        private boolean add_(final object<? extends _BaseObject_> p1) {
           if (p1._isValid()) {
              ObjectOps.increment(p1.ref());
              return objects.add(p1);
+          }
           return false;
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "AddArray", parameters = {
                 @LegacyParameter(name = "p1", type = "OBJECT", extent = -1, qualified = "progress.lang.object", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
-...
           object<? extends _BaseObject_> p1[] = TypeFactory.initInput(_p1);
           return function(this, "AddArray", logical.class, new Block((Body) () -> {
              if (p1.length > 0)
              for (object<? extends _BaseObject_> obj : p1)
+             {
                 objects.addAll(Arrays.asList(p1));
                 add_(obj);
+             }
              returnNormal(true);
-...
           return function(this, "AddAll", logical.class, new Block((Body) () -> {
              if (ObjectOps.typeOf(p1, LegacyCollection.class).booleanValue())
+             {
                 objects.addAll(ObjectOps.cast(p1, LegacyCollection.class).ref().objects);
                 for (object<? extends _BaseObject_> obj : ObjectOps.cast(p1, LegacyCollection.class).ref().objects)
+                {
                    add_(obj);
+                }
                 returnNormal(true);
+             }
              else
-...
        protected object<? extends _BaseObject_> _find(
                 final object<? extends _BaseObject_> checkObject)
+       {
           // in 4GL objects are also matched using equals (LegacyEquals)
           if (checkObject._isValid())
+          {
              if (objects.contains(checkObject))
                 return checkObject;
              List<object<? extends _BaseObject_>> items = objects.stream()
                       .filter(o -> o.equals(checkObject)).collect(Collectors.toList());
              // if more objects found (duplicate) 4GL sees it as ambiguous
              if (items.size() == 1)
+             {
                 return items.get(0);
+             }
              // in 4GL objects are also matched using equals (LegacyEquals)
              Optional<object<? extends _BaseObject_>> found = objects.stream()
                       .filter(o -> checkObject.ref().legacyEquals(o).booleanValue()).findFirst();
              if (found.isPresent())
+             {
                 return found.get();
+             }
+          }
           return checkObject;
           return TypeFactory.object(_BaseObject_.class);
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "ContainsAll", parameters = {

src/com/goldencode/p2j/oo/core/collections/LegacyIterator.java 2021-02-23 07:39:32 +0000
336	336	}
337	337	else if (qry.getNumResults().intValue() == 1 && qry.currentRow().intValue() == 1)
338	338	{
339		returnNormal(bufferHandle.unwrapBuffer().available());
	339	returnNormal(!bufferHandle.unwrapBuffer().available().booleanValue());
340	340	}
341	341	else
342	342	{
...	...
373	373	else
374	374	{
375	375	queryHandle.unwrapQuery().next();
	376	object<_BaseObject_> ret = TypeFactory.object(_BaseObject_.class);
	377
376	378	if (bufferHandle.unwrapBuffer()._available())
377	379	{
378		returnNormal(objectFieldHandle.unwrapBufferField().value());
379		}
380		else
381		{
382		returnNormal(new object<>());
383		}
	380	ret.assign(objectFieldHandle.unwrapBufferField().value());
	381	}
	382
	383	returnNormal(ret);
384	384	}
385	385	}));
386	386	}

     ** 001 ME  20200427 First version, stubs taken by converting the skeleton using FWD.
     ** 002 CA  20210113 Renamed Iiterator.next to Iiterator.next_, to follow NameConverter's rules.
     **                  Renamed clear() to clear_(), to follow NameConverter's rules.
     **     ME  20210205 Removed getMap method from interface definition, this is FWD specific.
     ** 003 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
     */
-...
                    }));
+       }
        @Override
        public Map<object, object> getMap()
+       {
           return map;

     **
     ** -#- -I- --Date-- -------------------------------Description--------------------------------
     ** 001 ME  20200427 First version, stubs taken by converting the skeleton using FWD.
     **     ME  20210205 Change second parameter of put method to longchar.
     **
     ** 002 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
-...
                 @LegacyParameter(name = "pcKey", type = "CHARACTER", mode = "INPUT"),
                 @LegacyParameter(name = "pcValue", type = "LONGCHAR", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public longchar put(final character pcKey, final Text pcValue)
        public longchar put(final character pcKey, final longchar pcValue)
+       {
           return function(StringStringMap.class, this, "Put", longchar.class, new Block((Body) () -> {
              object<LegacyString> key = ObjectOps.newInstance(LegacyString.class, "I", pcKey);

     ** 002 MP   20200703 Complete code with methods like legacy class
     ** 003 MP   20210112 improve constructor behavior and add file name in loop
     ** 004 ME   20210128 Fix ctor/execute names.
     **     ME   20210204 Complete implementation as of OE12.2.
     ** 005 CA   20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                   signature.
     */
-...
     import static com.goldencode.p2j.util.BlockManager.onBlockLevel;
     import static com.goldencode.p2j.report.ReportConstants.*;
     import static com.goldencode.p2j.util.BlockManager.returnNormal;
     import static com.goldencode.p2j.util.BlockManager.undoThrow;
     import com.goldencode.p2j.oo.lang.SysError;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.BlockManager.Action;
     import com.goldencode.p2j.util.BlockManager.Condition;
-...
      * in Progress/IO/FileInputStream.cls).
      */
     @LegacyResource(resource = "Progress.IO.FileInputStream")
     @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
     @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
     public class FileInputStream
     extends InputStream
+    {
        @LegacySignature(type = Type.PROPERTY, name = "FileName")
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        private character fileName = TypeFactory.character();
        private long fileSize;
        private long bytesLeft;
        private Stream sFileStream = new StreamWrapper("sFile");
        public void __io_FileInputStream_execute__()
+       {
           externalProcedure(FileInputStream.class, FileInputStream.this, new Block((Body) () ->
-...
+       {
           @LegacyParameter(name = "filename", type = "CHARACTER", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public void __io_FileInputStream_constructor__(final character _filename)
+       {
           character filename = TypeFactory.initInput(_filename);
-...
           internalProcedure(FileInputStream.class, this, "__io_FileInputStream_constructor__", new Block((Body) () ->
+          {
              __io_InputStream_constructor__();
              if (filename.isUnknown())
+             {
                 undoThrow(SysError.newInstance("Invalid file name specified  for 'Progress.IO.FileInputStream'", 18195, false, false));
+             }
              this.fileName.assign(filename);
              try
+             {
                 sFileStream.assign(StreamFactory.openFileStream((filename).toStringMessage(), false, false));
                 sFileStream.setBinary();
                 sFileStream.setConvert(false);
                 FileSystemOps.initFileInfo(fileName);
                 fileSize = FileSystemOps.fileInfoGetSize().longValue();
                 bytesLeft = fileSize;
+             }
              catch (Exception e)
+             {
                 undoThrow(SysError.newInstance("Cannot find or open file %s, errno = 2", 11294, true, false));
+             }
           }));
+       }
        @LegacySignature(returns = "CHARACTER", type = Type.GETTER, name = "FileName")
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public character getFileName()
+       {
           return function(FileInputStream.class, this, "FileName", character.class, new Block((Body) () ->
-...
        @LegacySignature(type = Type.METHOD, name = "Close")
        @Override
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public void close()
+       {
           internalProcedure(FileInputStream.class, this, "Close", new Block((Body) () ->
+          {
              UnimplementedFeature.missing("FileInputStream:Close METHOD");
              sFileStream.closeIn();
              super.close();
           }));
+       }
-...
           @LegacyParameter(name = "target", type = "MEMPTR", mode = "INPUT")
        })
        @Override
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        public int64 read(final memptr _target)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public int64 read(final memptr target)
+       {
           memptr target = TypeFactory.initInput(_target);
           return function(FileInputStream.class, this, "Read", int64.class, new Block((Body) () ->
+          {
              UnimplementedFeature.missing("FileInputStream:Read1 METHOD");
              returnNormal(read(target, new int64(1), target.length()));
           }));
+       }
-...
           @LegacyParameter(name = "n", type = "INT64", mode = "INPUT")
        })
        @Override
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public int64 skipBytes(final int64 _n)
+       {
           int64 n = TypeFactory.initInput(_n);
           memptr mdata = TypeFactory.memptr();
           return function(FileInputStream.class, this, "SkipBytes", int64.class, new Block((Body) () ->
+          {
              UnimplementedFeature.missing("FileInputStream:SkipBytes METHOD");
              if (getClosed().booleanValue())
+             {
                 undoThrow(SysError.newInstance("Cannot invoke method 'SkipBytes' after stream has been closed", 18196, false, false));
+             }
              if (n.isUnknown())
+             {
                 undoThrow(SysError.newInstance("Invalid value specified for parameter 'length' of method or constructor 'SkipBytes'", 18193, false, true));
+             }
              if (n.longValue() < 1)
+             {
                 returnNormal(0);
+             }
              mdata.setLength(n);
              read(mdata);
              returnNormal(n);
           }, (Fini) () -> {
              mdata.setLength(0);
           }));
+       }
-...
           @LegacyParameter(name = "length", type = "INT64", mode = "INPUT")
        })
        @Override
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public int64 read(final memptr _target, final int64 _offset, final int64 _length)
+       {
           memptr target = TypeFactory.initInput(_target);
           int64 offset = TypeFactory.initInput(_offset);
           int64 length = TypeFactory.initInput(_length);
           memptr vmem = TypeFactory.memptr();
           return function(FileInputStream.class, this, "Read", int64.class, new Block((Body) () ->
+          {
              UnimplementedFeature.missing("FileInputStream:Read2 METHOD");
              if (getClosed().booleanValue())
+             {
                 undoThrow(SysError.newInstance("Cannot invoke method 'Read' after stream has been closed", 18196, false, false));
+             }
              if (target.length().longValue() == 0)
+             {
                 undoThrow(SysError.newInstance("Invalid parameter: An initialized MEMPTR must be provided for the Read method or constructor", 19066, false, true));
+             }
              if (offset.isUnknown() || offset.longValue() < 1 || offset.longValue() > target.length().longValue())
+             {
                 undoThrow(SysError.newInstance("Invalid value specified for parameter 'offset' of method or constructor 'Read'", 18193, false, true));
+             }
              if (length.isUnknown() || length.longValue() < 0)
+             {
                 undoThrow(SysError.newInstance("Invalid value specified for parameter 'length' of method or constructor 'Read'", 18193, false, true));
+             }
              long toRead = bytesLeft;
              if (bytesLeft > 0)
+             {
                 toRead = Math.min(bytesLeft, Math.min(length.longValue(), target.length().longValue() + 1 - offset.longValue()));
+             }
              // easy way out
              if (toRead > 0)
+             {
                 bytesLeft -= toRead;
                 // read straight into the given memptr
                 if (offset.longValue() == 1 && toRead == target.length().longValue())
+                {
                    sFileStream.readBlock(target);
+                }
                 else
+                {
                    vmem.setLength(toRead);
                    sFileStream.readBlock(vmem);
                    target.setBytes(vmem, offset);
+                }
                 sFileStream.resetCurrentLine();
+             }
              returnNormal(toRead);
           }, (Fini) () -> {
              vmem.setLength(0);
           }));
+       }
-...
           @LegacyParameter(name = "target", type = "CHARACTER", mode = "OUTPUT")
        })
        @Override
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public int64 read(final character _delimiter, final character target)
+       {
           character delimiter = TypeFactory.initInput(_delimiter);
           return function(FileInputStream.class, this, "Read", int64.class, new Block((Init) () ->
+          {
              TypeFactory.initOutput(target);
           },
           (Body) () ->
+          {
              UnimplementedFeature.missing("FileInputStream:Read3 METHOD");
           return function(FileInputStream.class, this, "Read", int64.class, new Block((Body) () ->
+          {
              undoThrow(SysError.newInstance("Cannot invoke Read method in 'Progress.IO.FileInputStream' because it is not implemented", 18192, false, false));
           }));
+       }
-...
           @LegacyParameter(name = "target", type = "LONGCHAR", mode = "OUTPUT")
        })
        @Override
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public int64 read(final character _delimiter, final longchar target)
+       {
           character delimiter = TypeFactory.initInput(_delimiter);
           return function(FileInputStream.class, this, "Read", int64.class, new Block((Init) () ->
+          {
              TypeFactory.initOutput(target);
           },
           (Body) () ->
+          {
              UnimplementedFeature.missing("FileInputStream:Read4 METHOD");
              undoThrow(SysError.newInstance("Cannot invoke Read method in 'Progress.IO.FileInputStream' because it is not implemented", 18192, false, false));
           }));
+       }
+    }

     ** 001 IAS  20190923 First version.
     ** 002 MP   20200703 Complete code with methods like legacy class
     ** 003 ME   20201209 Fully implement non-abstract methods.
     **     ME   20210204 Add destructor to automatically close the stream.
     ** 004 CA   20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                   signature.
     */
-...
              __lang_BaseObject_constructor__();
           }));
+       }
        @LegacySignature(type = Type.DESTRUCTOR)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public void __io_InputStream_destructor__()
+       {
           internalProcedure(this, "__io_InputStream_destructor__", new Block((Body) () ->
+          {
              close();
           }));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.GETTER, name = "Closed")
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)

      ** 001 HC  20190701 Initial version.
      ** 002 HC  20190714 Added more serializable number types.
      ** 003 ME  20210128 Escape forward slash as in 4GL, json data type names.
      **         20210215 Extend pretty printer to match the 4GL formated output.
      */
     /*
-...
     import com.fasterxml.jackson.core.io.SerializedString;
     import com.fasterxml.jackson.core.*;
     import com.fasterxml.jackson.core.util.*;
     import com.fasterxml.jackson.core.util.DefaultPrettyPrinter.Indenter;
     import com.goldencode.p2j.oo.json.objectmodel.*;
     import com.goldencode.p2j.util.*;
     import java.io.*;
     import java.math.*;
     import java.nio.charset.Charset;
     import java.util.*;
     /**
-...
           JsonGenerator gen = factory.createGenerator(target, enc);
           if (prettyPrint)
+          {
              // TODO: there are some small differences how 4GL formats the output,
              //       for example new object bracket as the first element in an array is
              //       put on new line
              gen.setPrettyPrinter(new DefaultPrettyPrinter());
              gen.setPrettyPrinter(ProPretyPrinter.instance());
+          }
           // 4GL escapes forward slash
           gen.setCharacterEscapes(new ProCharacterEscapes());
           gen.setCharacterEscapes(ProCharacterEscapes.instance());
           writeConstruct(gen, construct);
           gen.flush();
           gen.close();
           // skip this as it will close the stream and not always what we need
           // gen.close();
           // 4GL add a new line at the end of document
           if (prettyPrint)
+          {
              target.write("\n".getBytes(Charset.forName(enc.getJavaName())));
+          }
           return enc.getJavaName();
+       }
-...
+          }
+       }
        private class ProCharacterEscapes extends CharacterEscapes {
        private static class ProCharacterEscapes extends CharacterEscapes {
           private static final long serialVersionUID = 1L;
           private static final ProCharacterEscapes _escapeInstance = new ProCharacterEscapes();
           public static ProCharacterEscapes instance() { return _escapeInstance; }
           private final SerializedString fwdSlash;
           private final int[] asciiEscapes;
           public ProCharacterEscapes()
           private ProCharacterEscapes()
+          {
              fwdSlash = new SerializedString("\\/");
              asciiEscapes = standardAsciiEscapesForJSON();
-...
              return null;
+          }
+       }
        private static class ProPretyPrinter extends DefaultPrettyPrinter {
           private static final long serialVersionUID = 1L;
           private static final ProPretyPrinter _printerInstance = new ProPretyPrinter();
           public static ProPretyPrinter instance() { return _printerInstance; }
           ProPretyPrinter() {
              indentArraysWith(TwoSpacesIndenter.instance());
              indentObjectsWith(TwoSpacesIndenter.instance());
+          }
           @Override
           public void writeObjectFieldValueSeparator(JsonGenerator g) throws IOException
+          {
              // no space between name and colon
              g.writeRaw(": ");
+          }
+       }
        private static class TwoSpacesIndenter implements Indenter
+       {
           private static final TwoSpacesIndenter _indenterInstance = new TwoSpacesIndenter();
           public static TwoSpacesIndenter instance() { return _indenterInstance; }
           @Override
           public boolean isInline()
+          {
              return false;
+          }
           @Override
           public void writeIndentation(JsonGenerator g, int level) throws IOException
+          {
              g.writeRaw('\n');
              for (int i = 0; i < level; i++)
+             {
                 g.writeRaw("  ");
+             }
+          }
+       }
+    }

     ** 006 HC  20190701 Implemented most of the legacy methods.
     ** 007 CA  20191024 Added method support levels and updated the class support level.
     ** 008 ME  20210130 Add missing methods (OE12.2), implement error handling 4GL compatible.
     **         20210215 Fix write method return.
     ** 009 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
     */
-...
        /**
         * Removes all values from this json object or array.
         */
        @Override
        protected void clear()
+       {
           for (Object o : elements)
-...
        })
        public logical read(final handle htt)
+       {
           return function(this, "Read", logical.class, new Block((Body) () -> {
              returnNormal(read(htt, new logical(false)));
           }));
           return read(htt, new logical(false));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
-...
           logical omit = TypeFactory.initInput(_omit);
           return function(this, "Read", logical.class, new Block((Body) () -> {
              logical ret = TypeFactory.logical();
              if (!htt._isValid() || !CompareOps._isEqual(htt.unwrapType().getResourceType(), "temp-table"))
              if (!htt._isValid() || !htt.isType("TEMP-TABLE"))
+             {
                 undoThrow(JsonError.newInstance(ErrorManager.getInvalidParameterError("temp-table handle", this,
                          "Read", "Not initialized or not a handle to a TEMP-TABLE."), 16070));
-...
              try
+             {
                 export.serializeTempTable(jb, tmpBuffer, !omit.isUnknown() && omit.booleanValue());
                 returnNormal(new logical(true));
                 ret.assign(true);
+             }
              catch (Exception e)
+             {
                 log.log(Level.WARNING, "", e);
                 returnError(ObjectOps.newInstance(JsonError.class));
+             }
              returnNormal(ret);
           }));
+       }
+    }

     ** Module   : JsonConstruct.java
     ** Abstract : Implementation of the Progress.Json.Objectmodel.JsonConstruct builtin class.
     **
     ** Copyright (c) 2018-2021, Golden Code Development Corporation.
     ** Copyright (c) 2018-2020, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- -------------------------------Description--------------------------------
     ** 001 OM  20181218 First version.
-...
     ** 010 CA  20200503 Added stub for JsonConstruct:read(handle).
     ** 011 ME  20201028 Add routine level undo throw to avoid 'eating' errors.
     **         20210128 Fix longchar to utf-8 for jsonText, 'null' string for nulls.
     **         20210209 Fix encoding parameter sent to write method (unknown instead of null).
     **         20210215 Remove clean/read methods, refactor write.
     ** 012 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
     */
-...
     import com.goldencode.p2j.oo.json.*;
     import com.goldencode.p2j.oo.lang.*;
     import com.goldencode.p2j.persist.*;
     import com.goldencode.p2j.persist.serial.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.ErrorManager;
     import com.goldencode.p2j.util.BlockManager.Action;
     import com.goldencode.p2j.util.BlockManager.Condition;
     import java.io.*;
     import java.nio.charset.*;
     import java.util.*;
     import java.util.function.*;
     import java.util.logging.*;
     import static com.goldencode.p2j.util.BlockManager.*;
-...
           }));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
+       {
           @LegacyParameter(name = "tt", type = "HANDLE", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical read(final TableParameter _tt)
+       {
           return read(_tt, new logical(false));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
+       {
           @LegacyParameter(name = "tt", type = "HANDLE", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_NONE)
        public logical read(final handle _tt)
+       {
           UnimplementedFeature.missing("JsonConstruct:read(handle)");
           return new logical(false);
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
+       {
           @LegacyParameter(name = "tt", type = "HANDLE", mode = "INPUT"),
           @LegacyParameter(name = "omit", type = "LOGICAL", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical read(final TableParameter _tt, final logical _omit)
+       {
           logical omit = TypeFactory.initInput(_omit);
           return function(this, "Read", logical.class, new Block((Body) () ->
+          {
              TemporaryBuffer tb = (TemporaryBuffer) ((BufferReference) _tt.getTable()).buffer();
              readImpl(tb, omit);
           }));
+       }
        /**
         * Writes the object graph referenced by this JSON construct into the given target.
+        *
         * @param    _strHndl
         *           The stream handle to use as a target.
+        *
         * @return   {@code true} if the serialization was successful.
         */
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Write", parameters =
+       {
           @LegacyParameter(name = "str-hndl", type = "HANDLE", mode = "INPUT"),
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical write(final handle strHndl)
+       {
           return write(strHndl, new logical(false), new character());
+       }
        /**
         * Writes the object graph referenced by this JSON construct into the given target.
+        *
-...
           @LegacyParameter(name = "fmtted", type = "LOGICAL", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical write(final handle _strHndl, final logical _fmtted)
        public logical write(final handle strHndl, final logical fmtted)
+       {
           handle strHndl = TypeFactory.initInput(_strHndl);
           logical fmtted = TypeFactory.initInput(_fmtted);
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              write(strHndl, fmtted, new character());
           }));
           return write(strHndl, fmtted, new character());
+       }
        /**
-...
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              Stream stream = (Stream) strHndl.getResource();
              writeImpl(fmtted, enc, (b, chset) ->
              OutputStream o = new OutputStreamWrapper(stream);
              logical ret = TypeFactory.logical();
              try {
                 writeImpl(o, fmtted, enc);
                 ret.assign(true);
+             }
              catch (Exception e)
+             {
                 try
+                {
                    stream.write(b);
                    return new logical(true);
+                }
                 catch (IOException e)
+                {
                    throw new RuntimeException(e);
+                }
              });
                 returnError(JsonError.newInstance(e.getMessage(), 0));
+             }
              returnNormal(ret);
           }));
+       }
-...
           @LegacyParameter(name = "target", type = "LONGCHAR", mode = "INPUT-OUTPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical write_1(final longchar target)
        public logical write(final longchar target)
+       {
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              writeImpl(null, null, (b, chset) ->
+             {
                 target.assign(new String(b, chset));
                 return new logical(true);
              });
           }));
           return write(target, new logical(false), new character());
+       }
        /**
-...
           @LegacyParameter(name = "fmtted", type = "LOGICAL", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical write(final longchar target, final logical _fmtted)
        public logical write(final longchar target, final logical fmtted)
+       {
           logical fmtted = TypeFactory.initInput(_fmtted);
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              writeImpl(fmtted, null, (b, chset) ->
+             {
                 target.assign(new String(b, chset));
                 return new logical(true);
              });
           }));
           return write(target, fmtted, new character());
+       }
        /**
-...
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              writeImpl(fmtted, enc, (b, chset) ->
+             {
                 target.assign(new String(b, chset));
                 return new logical(true);
              });
              ByteArrayOutputStream out = new ByteArrayOutputStream();
              logical ret = TypeFactory.logical();
              if (TextOps.isEmpty(enc))
+             {
                 enc.assign("UTF-8");
+             }
              try {
                 Charset ch = writeImpl(out, fmtted, enc);
                 target.setUnknown();
                 target.fixCodePage(enc);
                 target.assign(new String(out.toByteArray(), ch));
                 ret.assign(true);
+             }
              catch (Exception e)
+             {
                 returnError(JsonError.newInstance(e.getMessage(), 0));
+             }
              returnNormal(ret);
           }));
+       }
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical write(final memptr _target)
+       {
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              returnNormal(write(_target, null, null));
           }));
           return write(_target, new logical(false), new character());
+       }
        /**
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical write(final memptr _target, final logical _fmtted)
+       {
           logical fmtted = TypeFactory.initInput(_fmtted);
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              returnNormal(write(_target, fmtted, null));
           }));
           return write(_target, _fmtted, new character());
+       }
        /**
-...
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              writeImpl(fmtted, enc, (b, chset) ->
              ByteArrayOutputStream out = new ByteArrayOutputStream();
              logical ret = TypeFactory.logical();
              try {
                 Charset ch = writeImpl(out, fmtted, enc);
                 _target.setLength(0);
                 _target.setLength(out.size());
                 _target.write(true, out.toByteArray(), 0, false);
                 ret.assign(true);
+             }
              catch (Exception e)
+             {
                 _target.assign(b);
                 return new logical(true);
              });
                 returnError(JsonError.newInstance(e.getMessage(), 0));
+             }
              returnNormal(ret);
           }));
+       }
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical write(final character target)
+       {
           return write(target, new logical(false));
           return write(target, new logical(false), new character());
+       }
        /**
-...
           return function(this, "Write", logical.class, new Block((Body) () ->
+          {
              writeImpl(fmtted, enc, (b, chset) ->
              ByteArrayOutputStream out = new ByteArrayOutputStream();
              logical ret = TypeFactory.logical();
              try {
                 Charset ch = writeImpl(out, fmtted, enc);
                 target.assign(new String(out.toByteArray(), ch));
                 ret.assign(true);
+             }
              catch (Exception e)
+             {
                 target.assign(new String(b, chset));
                 return new logical(true);
              });
                 returnError(JsonError.newInstance(e.getMessage(), 0));
+             }
              returnNormal(ret);
           }));
+       }
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical writeFile(final character _fname, final logical _fmtted, final character _enc)
+       {
           character fname  = TypeFactory.initInput(_fname);
           logical fmtted = TypeFactory.initInput(_fmtted);
           character enc  = TypeFactory.initInput(_enc);
           return function(this, "Write", logical.class, new Block((Body) () ->
           return function(this, "WriteFile", logical.class, new Block((Body) () ->
+          {
              writeImpl(fmtted, enc, (b, chset) ->
+             {
                 Stream s = StreamFactory.openFileStream(_fname.toStringMessage(), true, false);
                 if (s == null)
+                {
                    return new logical(false);
+                }
                 else
+                {
                    try
+                   {
                       s.write(b);
                       s.close();
+                   }
                    catch (IOException e)
+                   {
                       throw new RuntimeException(e);
+                   }
                    return new logical(true);
+                }
              });
              if (TextOps.isEmpty(fname))
+             {
                 undoThrow(JsonError.newInstance(ErrorManager.getInvalidParameterError("filename", this,
                          "WriteFile", "Can not be UNKNOWN (?) or empty string."), 16055));
+             }
              Stream s = StreamFactory.openFileStream(fname.toStringMessage(), true, false);
              OutputStream o = new OutputStreamWrapper(s);
              logical ret = TypeFactory.logical();
              try {
                 writeImpl(o, fmtted, enc);
                 ret.assign(true);
+             }
              catch (Exception e)
+             {
                 returnError(JsonError.newInstance(e.getMessage(), 0));
              } finally {
                 s.closeOut();
+             }
              returnNormal(ret);
           }));
+       }
-...
           return function(this, "WriteStream", logical.class, new Block((Body) () ->
+          {
              if (sname.isUnknown())
+             {
                 returnError(ObjectOps.newInstance(JsonError.class));
+             }
              else
+             {
                 Stream s = StreamFactory.findOutputStream(sname.toStringMessage());
                 if (s == null)
+                {
                    returnNormal(new logical(false));
+                }
                 else
+                {
                    boolean pretty = fmtted != null && !fmtted.isUnknown() && fmtted.booleanValue();
                    OutputStream o = new OutputStreamWrapper(s);
                    try
+                   {
                       JsonBackend.instance().write(o,
                                                    this, pretty,
                                                    enc.isUnknown() ? null : enc.toStringMessage());
                       returnNormal(new logical(true));
+                   }
                    catch (IOException e)
+                   {
                       log.log(Level.WARNING, "", e);
                       returnError(ObjectOps.newInstance(JsonError.class));
+                   }
+                }
+             }
              logical ret = TypeFactory.logical();
              Stream s = StreamFactory.findOutputStream(sname.isUnknown() ? null : sname.toStringMessage());
              if (s != null)
+             {
                 boolean pretty = fmtted != null && !fmtted.isUnknown() && fmtted.booleanValue();
                 OutputStream o = new OutputStreamWrapper(s);
                 try
+                {
                    JsonBackend.instance().write(o,
                                                 this, pretty,
                                                 enc.isUnknown() ? null : enc.toStringMessage());
                    ret.assign(true);
+                }
                 catch (Exception e)
+                {
                    log.log(Level.WARNING, "", e);
                    returnError(ObjectOps.newInstance(JsonError.class));
+                }
+             }
              returnNormal(ret);
           }));
+       }
-...
         * @param   converter
         *          Bi function instance that will receive the serialized bytes and return {@code BaseDateType}
         *          value that will be "returned" with the call to {@link BlockManager#returnNormal}.
         * @throws Exception
         */
        protected void writeImpl(logical fmted, character enc, BiFunction<byte[], Charset, BaseDataType> converter)
        protected Charset writeImpl(OutputStream out, logical fmted, character enc) throws Exception
+       {
           ByteArrayOutputStream out = new ByteArrayOutputStream();
           boolean pretty = fmted != null && !fmted.isUnknown() && fmted.booleanValue();
           String legacyEnc = enc != null && !enc.isUnknown() ? enc.toStringMessage() : null;
           try
+          {
              String javaEnc = JsonBackend.instance().write(out, this, pretty, legacyEnc);
              returnNormal(converter.apply(out.toByteArray(), Charset.forName(javaEnc)));
+          }
           catch (UnsupportedEncodingException e)
+          {
              log.log(Level.WARNING, "", e);
              returnError(ObjectOps.newInstance(JsonError.class));
+          }
           catch (IOException e)
+          {
              log.log(Level.WARNING, "", e);
              returnError(ObjectOps.newInstance(JsonError.class));
+          }
           catch (StackUnwindException e)
+          {
              throw e;
+          }
           catch (RuntimeException e)
+          {
              log.log(Level.WARNING, "", e);
              returnError(ObjectOps.newInstance(JsonError.class));
+          }
           return Charset.forName(JsonBackend.instance().write(out, this, pretty, legacyEnc));
+       }
        /**
-...
+       }
        /**
         * Implements the method {@link #read(TableParameter)} and {@link #read(TableParameter, logical)} for
         * json object and array classes.
+        *
         * @param   tb
         *          Temp buffer to read.
         * @param   omit
         *          {@code true} to omit initial values, {@code false} otherwise.
         */
        protected void readImpl(TemporaryBuffer tb, final logical omit)
+       {
           ObjectBuilder jb = new ObjectBuilder(this);
           clear();
           JsonExport export = new JsonExport();
           try
+          {
              export.exportTempBuffer(tb, omit, new logical(false), jb);
              returnNormal(new logical(true));
+          }
           catch (PersistenceException e)
+          {
              log.log(Level.WARNING, "", e);
              returnError(ObjectOps.newInstance(JsonError.class));
+          }
+       }
        /**
         * Removes all values from this json object or array.
         */
        protected abstract void clear();
        /**
         * Json structure callback for building the json objects.
         */
        protected static class ObjectBuilder

     ** 007 HC  20190803 Fixed an NPE condition in read().
     ** 008 CA  20191024 Added method support levels and updated the class support level.
     ** 009 CA  20191013 read(handle) can load either a TEMP-TABLE or DATASET.
     ** 010 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     ** 010 ME  20210215 Fixing read methods.
     ** 011 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy
     **                  signature.
     */
-...
     import com.goldencode.p2j.oo.lang.*;
     import com.goldencode.p2j.persist.*;
     import com.goldencode.p2j.persist.serial.*;
     import com.goldencode.p2j.ui.chui.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.BlockManager.Action;
     import com.goldencode.p2j.util.BlockManager.Condition;
     import java.io.*;
     import java.time.format.*;
-...
+       {
           externalProcedure(JsonObject.this, new Block((Body) () ->
+          {
+             {
+             }
              onBlockLevel(Condition.ERROR, Action.THROW);
           }));
+       }
-...
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
+       {
           @LegacyParameter(name = "pds", type = "HANDLE", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical read(final DataSetParameter _pds)
+       {
           return read(_pds, new logical(false));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
+       {
           @LegacyParameter(name = "pds", type = "HANDLE", mode = "INPUT"),
           @LegacyParameter(name = "omit", type = "LOGICAL", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical read(final DataSetParameter _pds, final logical _omit)
+       {
           return read(_pds, _omit, new logical(false));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
+       {
           @LegacyParameter(name = "pds", type = "HANDLE", mode = "INPUT"),
           @LegacyParameter(name = "omit", type = "LOGICAL", mode = "INPUT"),
           @LegacyParameter(name = "b4img", type = "LOGICAL", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical read(final DataSetParameter _pds, final logical _omit, final logical _b4img)
+       {
           logical omit = TypeFactory.initInput(_omit);
           logical b4img = TypeFactory.initInput(_b4img);
           return function(this, "Read", logical.class, new Block((Init) () ->
+          {
              ObjectBuilder jb = new ObjectBuilder(this);
              properties.clear();
              try
+             {
                 JsonExport export = new JsonExport();
                 export.exportDataSet(_pds.getDataset(), false, omit.booleanValue(), b4img.booleanValue(), jb);
                 returnNormal(new logical(true));
+             }
              catch (PersistenceException e)
+             {
                 log.log(Level.WARNING, "", e);
                 returnError(ObjectOps.newInstance(JsonError.class));
+             }
           }));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
+       {
           @LegacyParameter(name = "bh", type = "HANDLE", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical read(final handle _bh)
+       {
           return read(_bh, new logical(false));
           return read(_bh, new logical(false), new logical(false));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical read(final handle _bh, final logical _omit)
+       {
           return read(_bh, _omit, new logical(false));
+       }
        @LegacySignature(returns = "LOGICAL", type = Type.METHOD, name = "Read", parameters =
+       {
           @LegacyParameter(name = "bh", type = "HANDLE", mode = "INPUT"),
           @LegacyParameter(name = "omit", type = "LOGICAL", mode = "INPUT"),
           @LegacyParameter(name = "b4img", type = "LOGICAL", mode = "INPUT")
        })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL|RT_LVL_FULL)
        public logical read(final handle _bh, final logical _omit, final logical _b4img)
+       {
           handle bh = TypeFactory.initInput(_bh);
           logical omit = TypeFactory.initInput(_omit);
           logical b4img = TypeFactory.initInput(_b4img);
           return function(this, "Read", logical.class, new Block((Init) () ->
+          {
              if (!bh.isUnknown())
-...
+                {
                    BufferImpl buf = (BufferImpl) res;
                    TemporaryBuffer tb = (TemporaryBuffer) buf.buffer();
                    readImpl(tb, omit);
                    returnNormal(readImpl(tb, omit));
+                }
                 else if (res instanceof TempTable)
+                {
                    TempTable tt = (TempTable) res;
                    TemporaryBuffer tb = (TemporaryBuffer) ((BufferImpl) tt.defaultBufferHandle().getResource()).buffer();
                    returnNormal(readImpl(tb, omit));
+                }
                 else if (res instanceof DataSet)
+                {
                    DataSet ds = (DataSet) res;
                    read(new DataSetParameter(ds), omit);
                    returnNormal(readImpl(ds, omit, b4img));
+                }
                 else
+                {
-...
        /**
         * Removes all values from this json object or array.
         */
        @Override
        protected void clear()
+       {
           for (Map.Entry<String, Object> e : properties.entrySet())
-...
              returnError(ObjectOps.newInstance(JsonError.class));
+          }
+       }
        protected logical readImpl(TemporaryBuffer tb, final logical omit)
+       {
           return function(this, "Read", logical.class, new Block((Body) () -> {
              ObjectBuilder jb = new ObjectBuilder(this);
              JsonExport export = new JsonExport();
              try
+             {
                 export.exportTempBuffer(tb, omit, new logical(false), jb);
                 returnNormal(new logical(true));
+             }
              catch (PersistenceException e)
+             {
                 log.log(Level.WARNING, "", e);
                 returnError(ObjectOps.newInstance(JsonError.class));
+             }

Project

General

Profile

FWD » Core Development » Base Language