3821c.4384g.patch

Marian Edu, 02/01/2021 08:26 AM

     **                  IsTrue.
     ** 003 IAS 20190923 Added implementation of additional methods
     ** 004 CA  20191024 Added method support levels and updated the class support level.
     ** 005 ME  20201023 Added implementation for isType, notType.
     */
     /*
-...
                 final character _p2)
+       {
           internalProcedure(Assert.class, "IsNull", new Block((Body) () -> {
              AssertObject.isNull(_p1, new character("argument"));
              AssertObject.isNull(_p1, _p2);
           }));
+       }
-...
        @LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
                 @LegacyParameter(name = "p1", type = "DECIMAL", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "CHARACTER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void isPositive(final decimal _p1, final character _p2)
+       {
           internalProcedure(Assert.class, "IsPositive", new Block((Body) () -> {
-...
        @LegacySignature(type = Type.METHOD, name = "IsType", parameters = {
                 @LegacyParameter(name = "p1", type = "HANDLE", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "OBJECT", qualified = "openedge.core.datatypeenum", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void isType(final handle _p1,
                 final object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> _p2)
+       {
           ObjectOps.load(Assert.class);
           handle p1 = TypeFactory.initInput(_p1);
           object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> p2 = TypeFactory.initInput(_p2);
           internalProcedure(Assert.class, "IsType", new Block());
           internalProcedure(Assert.class, "IsType", new Block((Body) () -> {
              AssertObject.isType(_p1, _p2, new character("argument"));
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "IsType", parameters = {
                 @LegacyParameter(name = "p1", type = "HANDLE", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "OBJECT", qualified = "openedge.core.datatypeenum", mode = "INPUT"),
                 @LegacyParameter(name = "p3", type = "CHARACTER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void isType(final handle _p1,
                 final object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> _p2,
                 final character _p3)
+       {
           ObjectOps.load(Assert.class);
           handle p1 = TypeFactory.initInput(_p1);
           object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> p2 = TypeFactory.initInput(_p2);
           character p3 = TypeFactory.initInput(_p3);
           internalProcedure(Assert.class, "IsType", new Block());
           internalProcedure(Assert.class, "IsType", new Block((Body) () -> {
              AssertObject.isType(_p1, _p2, _p3);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "IsType", parameters = {
-...
        @LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
                 @LegacyParameter(name = "p1", type = "INT64", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "CHARACTER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void isZero(final int64 _p1, final character _p2)
+       {
           ObjectOps.load(Assert.class);
-...
        @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                 @LegacyParameter(name = "p1", type = "HANDLE", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "CHARACTER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void notNull(final handle _p1, final character _p2)
+       {
           handle p1 = TypeFactory.initInput(_p1);
-...
        @LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
                 @LegacyParameter(name = "p1", type = "INTEGER", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "CHARACTER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void notNullOrZero(final integer _p1, final character _p2)
+       {
           internalProcedure(Assert.class, "NotNullOrZero", new Block((Body) () -> {
-...
                 @LegacyParameter(name = "p1", type = "HANDLE", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "OBJECT", qualified = "openedge.core.datatypeenum", mode = "INPUT"),
                 @LegacyParameter(name = "p3", type = "CHARACTER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void notType(final handle _p1,
                 final object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> _p2,
                 final character _p3)
+       {
           handle p1 = TypeFactory.initInput(_p1);
           object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> p2 = TypeFactory.initInput(_p2);
           character p3 = TypeFactory.initInput(_p3);
           internalProcedure(Assert.class, "NotType", new Block());
           internalProcedure(Assert.class, "NotType", new Block((Body) () -> {
              AssertObject.notType(_p1, _p2, _p3);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "NotType", parameters = {

     ** 003 CA  20200313 Fixed a typo in putBytes_1 LegacySignature annotation.
     ** 004 GES 20200429 Shifted to new legacy enum approach.
     ** 005 ME  20200604 Rewrite to match the 4GL implementation.
     **         20201019 Always write at the end regardless of position set, check max size
     **         boundary (2G).
     ** 006 CA  20210113 Renamed clear() to clear_(), to follow NameConverter's rules.
     */
-...
     import java.util.*;
     import org.apache.commons.lang3.*;
     /**
      * Business logic (converted to Java from the 4GL source code
      * in OpenEdge/Core/ByteBucket.cls).
-...
        /** The current position */
        protected int64 position = TypeFactory.int64(0L);
        /** The current write position, putBytes always seems to write at the end regardless of position set **/
        private long writePosition = 0L;
        /** The bucket size (total number of bytes) */
        protected int64 size = TypeFactory.int64(0L);
        private integer initialNumRecs = TypeFactory.integer(3L);
        private int currentDataIndex;
        /** List of rows */
        protected LinkedList<BucketEntry> buckets = new LinkedList<>();
        protected LinkedList<byte[]> buckets = new LinkedList<>();
        /**
         * Execute method
-...
        public int64 getSize()
+       {
           return function(this, "Size", int64.class, new Block((Body) () -> {
              returnNormal(size);
              // make sure size is not unknown (destroy), $GL BUG probably not checking for valid object
              if (size.isUnknown())
+             {
                 ErrorManager.recordOrThrowError(3135, "Invalid handle. Not initialized or points to a deleted object");
+             }
              else
+             {
                 returnNormal(size);
+             }
           }));
+       }
-...
        public void __core_ByteBucket_constructor__()
+       {
           internalProcedure(this, "__core_ByteBucket_constructor__", new Block((Body) () -> {
              __core_ByteBucket_constructor__(initialNumRecs);
              __core_ByteBucket_constructor__(new int64(0));
           }));
+       }
        /**
         * Constructor.
+        *
         * @param _p1 the initial size of the memptrs that are held in the Bucket's array.
         */
        @LegacySignature(type = Type.CONSTRUCTOR, parameters = {
                 @LegacyParameter(name = "p1", type = "INT64", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void __core_ByteBucket_constructor__(final int64 _p1)
+       {
           // default capacity sent as input ignored on 4GL implementation, deprecated
           // since 11.7.0
           __core_ByteBucket_constructor__(initialNumRecs);
+       }
        /**
         * Constructor.
+        *
         * @param _p1 the initial size of the memptrs that are held in the Bucket's array.
         */
        @LegacySignature(type = Type.CONSTRUCTOR, parameters = {
                 @LegacyParameter(name = "p1", type = "INTEGER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void __core_ByteBucket_constructor__(final integer _p1)
+       {
           integer p1 = TypeFactory.initInput(_p1);
         * @param defaultCapacity the default capacity of the memptrs that are held in the Bucket's array.
         */
        @LegacySignature(type = Type.CONSTRUCTOR, parameters = {
                 @LegacyParameter(name = "defaultCapacity", type = "INT64", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void __core_ByteBucket_constructor__(final int64 _defaultCapacity)
+       {
           int64 defaultCapacity = TypeFactory.initInput(_defaultCapacity);
           internalProcedure(this, "__core_ByteBucket_constructor__", new Block((Body) () -> {
              __lang_BaseObject_constructor__();
              Assert.isPositive(p1, new character("Initial size"));
              position.assign(1);
              defaultCapacity.assign(MAX_BYTES_PER_ROW);
              initialNumRecs.assign(p1);
              currentDataIndex = 0;
              // just throw a 'matching' error for now until implementation is using the new MemoryOutputStream
              if (defaultCapacity.isUnknown() || defaultCapacity.longValue() < 0) {
                 ErrorManager.recordOrThrowError(18193, "Invalid value specified for parameter 'value' of method or constructor 'Progress.IO.MemoryOutputStream'.");
+             }
              if (defaultCapacity.longValue() != 0 ) {
                 if (defaultCapacity.longValue() > Integer.MAX_VALUE ) {
                    ErrorManager.recordOrThrowError(0, "The initial stream size cannot be greater than 2GB");
+                }
                 // pre-allocate memory???
                 for (int i = 0; i < (int) (defaultCapacity.longValue() / MAX_BYTES_PER_ROW); i++)
+                {
                    buckets.add(new byte[MAX_BYTES_PER_ROW]);
+                }
+             }
              this.defaultCapacity.assign(defaultCapacity);
              this.position.assign(1);
           }));
+       }
        /**
         * Constructor.
+        *
         * @param initialSize the initial size of the memptrs that are held in the Bucket's array.
         */
        @LegacySignature(type = Type.CONSTRUCTOR, parameters = {
                 @LegacyParameter(name = "initialSize", type = "INTEGER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void __core_ByteBucket_constructor__(final integer _initialSize)
+       {
           integer initialSize = TypeFactory.initInput(_initialSize);
           internalProcedure(this, "__core_ByteBucket_constructor__", new Block((Body) () -> {
              __core_ByteBucket_constructor__();
              Assert.isPositive(initialSize, new character("Initial size"));
           }));
+       }
-...
         * @param _p2 the initial number of buckets (not used in  the current implementation).
         */
        @LegacySignature(type = Type.CONSTRUCTOR, parameters = {
                 @LegacyParameter(name = "p1", type = "INTEGER", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "INT64", mode = "INPUT") })
                 @LegacyParameter(name = "initialSize", type = "INTEGER", mode = "INPUT"),
                 @LegacyParameter(name = "defaultCapacity", type = "INT64", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void __core_ByteBucket_constructor__(final integer p1, final int64 p2)
        public void __core_ByteBucket_constructor__(final integer initialSize, final int64 defaultCapacity)
+       {
           // default capacity input parameter ignored on 4GL, deprecated since 11.7.0
           __core_ByteBucket_constructor__(p1);
           // in OE12.2 initial size (number of rows) is not used anymore but default capacity (bytes) is used instead
           __core_ByteBucket_constructor__(defaultCapacity);
+       }
        /**
-...
           internalProcedure(this, "Clear", new Block((Body) () -> {
              this.position.assign(1);
              this.size.assign(0);
              currentDataIndex = 0;
              for (BucketEntry bucket : buckets)
+             {
                 bucket.bytesWritten = 0;
+             }
           }));
+       }
        /**
         * Debug method to dump out current RAW bytes into numbered files.
         * Files are named bytebucket-memptr-&lt;number&gt;.bin
         * Debug method to dump out current RAW bytes into a file.
         * The file is saved in session temporary folder as "bytebucket-memptr-&lt;object_id&gt;.bin"
         */
        @LegacySignature(type = Type.METHOD, name = "Debug")
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void debug()
+       {
           internalProcedure(this, "Debug", new Block((Body) () -> {
              String folderPath = EnvironmentOps.getTempDirectory().getValue();
              character fullPath = TypeFactory.character();
              for (int i = 0; i < buckets.size(); i++)
+             {
                 BucketEntry bucket = buckets.get(i);
                 memptr ptr = new memptr(Arrays.copyOf(bucket.data, bucket.bytesWritten));
                 fullPath.assign(String.format("%sbytebucket-memptr-%d.bin", folderPath, i + 1));
                 try
+                {
                    new LobCopy(new SourceLob(ptr), new TargetLobFile(fullPath)).run();
+                }
                 finally
+                {
                    ptr.setLength(0);
+                }
+             }
              String debugPath = String.format("%sbytebucket-memptr-%d.bin",
                       EnvironmentOps.getTempDirectory().getValue(),
                       handle.resourceId(ObjectOps.asResource(this)));
              memptr ptr = getBytes().ref().getValue();
              try
+             {
                 new LobCopy(new SourceLob(ptr), new TargetLobFile(debugPath)).run();
+             }
              finally
+             {
                 ptr.setLength(0);
+             }
           }));
+       }
-...
+       {
           internalProcedure(this, "Destroy", new Block((Body) () -> {
              this.position.assign(1);
              this.size.assign(0);
              currentDataIndex = 0;
              this.size.setUnknown();
              buckets.clear();
           }));
-...
           int64 p = TypeFactory.initInput(_pos);
           return function(this, "GetByte", integer.class, new Block((Body) () -> {
              Assert.isPositive(p, new character("Start position"));
              long pos = p.longValue();
              int nbucket = (int) ((pos - 1) / defaultCapacity.longValue());
              int offset = (int) ((pos - 1) % defaultCapacity.longValue());
              if (nbucket < buckets.size())
+             {
                 BucketEntry bucket = buckets.get(nbucket);
                 if (offset < bucket.bytesWritten)
                    returnNormal(new integer(bucket.data[offset]));
                 // data in 4GL blob field is truncated, read pass length returns unknown
                 returnNormal(new integer());
              if (!p.isUnknown()) {
                 long pos = p.longValue();
                 if (pos < 1)
+                {
                    BinaryData.genIndexError();
+                }
                 else if (pos <= size.longValue())
+                {
                    int nbucket = (int) ((pos - 1) / MAX_BYTES_PER_ROW);
                    int offset = (int) ((pos - 1) % MAX_BYTES_PER_ROW);
                    if (nbucket < buckets.size())
+                   {
                       byte[] bucket = buckets.get(nbucket);
                       returnNormal(new integer(bucket[offset] & 0xFF));
+                   }
+                }
+             }
              returnNormal(new integer(0));
           }));
+       }
-...
           int64 size = TypeFactory.initInput(_size);
           return function(this, "GetBytes", object.class, new Block((Body) () -> {
              if (CompareOps._isEqual(size, 0) || CompareOps._isEqual(getSize(), 0))
              if (getSize().longValue() == 0 || size.longValue() == 0)
+             {
                 returnNormal(Memptr.getEmpty());
+             }
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public longchar getString()
+       {
           return getString(new int64(1), this.size);
           return getString(new int64(1), this.getSize());
+       }
        /**
-...
              Assert.isPositive(pos, new character("Start position"));
              Assert.isZeroOrPositive(size, new character("Slice size"));
              if (StringUtils.isBlank(targetCP.getValue()))
              if (TextOps.isEmpty(targetCP))
                 targetCP.assign("UTF-8");
              longchar lc = TypeFactory.longchar();
-...
                 returnNormal(lc);
+             }
              if (StringUtils.isBlank(sourceCP.getValue()))
              if (TextOps.isEmpty(sourceCP))
                 sourceCP.assign("UTF-8");
              memptr ptr = TypeFactory.memptr();
-...
+       {
           internalProcedure(this, "Initialize", new Block((Body) () -> {
              clear_();
              resize(initialNumRecs);
           }));
+       }
-...
        public static object<? extends ByteBucket> instance(final int64 _p1)
+       {
           int64 p1 = TypeFactory.initInput(_p1);
           ObjectOps.load(ByteBucket.class);
           return function(ByteBucket.class, "Instance", object.class, new Block((Body) () -> {
              object<? extends ByteBucket> bb = ObjectOps.newInstance(ByteBucket.class, "I", p1);
              bb.ref().initialize();
-...
+       {
           integer p1 = TypeFactory.initInput(_p1);
           int64 p2 = TypeFactory.initInput(_p2);
           ObjectOps.load(ByteBucket.class);
           return function(ByteBucket.class, "Instance", object.class, new Block((Body) () -> {
              Assert.isPositive(p1, new character("Initial size"));
              object<? extends ByteBucket> bb = ObjectOps.newInstance(ByteBucket.class, "II", p1, p2);
              bb.ref().initialize();
              returnNormal(bb);
           }));
+       }
        private static void mergeBuckets(final ByteBucket source, final ByteBucket target)
+       {
           int total = source.getSize().intValue();
           if (total == 0)
+          {
              return;
+          }
           source.buckets.stream().filter(b -> b.bytesWritten > 0)
                    .forEachOrdered(b -> target.writeBytes(b.data, b.bytesWritten));
+       }
        /**
         * Copies all of the bytes from a ByteBucket instance into this bucket.
+        *
-...
        @LegacySignature(type = Type.METHOD, name = "PutBytes", parameters = {
                 @LegacyParameter(name = "data", type = "OBJECT", qualified = "openedge.core.bytebucket", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void putBytes(final object<? extends ByteBucket> data)
        public void putBytes(final object<? extends ByteBucket> _data)
+       {
           object<? extends ByteBucket> data = TypeFactory.initInput(_data);
           internalProcedure(this, "PutBytes", new Block((Body) () -> {
              Assert.notNull(data, new character("Input data"));
              if (data.getSize() > 0)
              ByteBucket bbucket = data.ref();
              long size = bbucket.getSize().longValue();
              if (size > 0)
+             {
                 mergeBuckets(data.ref(), this);
                 int endBucket = (int) (size / MAX_BYTES_PER_ROW);
                 int endOffset = (int) (size % MAX_BYTES_PER_ROW);
                 for (int i = 0; i <= endBucket; i++)
+                {
                    byte[] bucket = bbucket.buckets.get(i);
                    writeBytes(bucket, i < endBucket ? MAX_BYTES_PER_ROW : endOffset);
+                }
+             }
           }));
+       }
-...
           character targetCP = TypeFactory.initInput(_targetCP);
           internalProcedure(this, "PutString", new Block((Body) () -> {
              if (!data.isUnknown() && StringUtils.isEmpty(data.getValue()))
              if (TextOps.isEmpty(data))
                 return;
              if (targetCP.isUnknown() || StringUtils.isEmpty(targetCP.getValue()))
              if (TextOps.isEmpty(targetCP))
+             {
                 targetCP.assign("UTF-8");
+             }
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void resize(final integer _p1)
+       {
           integer psize = TypeFactory.initInput(_p1);
           internalProcedure(this, "Resize", new Block((Body) () -> {
              if (!psize.isUnknown())
+             {
                 if (psize.intValue() > currentDataIndex)
+                {
                    for (int i = currentDataIndex + 1; i < psize.intValue(); i++)
+                   {
                       if (buckets.size() < i)
+                      {
                          buckets.add(new BucketEntry());
+                      }
+                   }
+                }
                 else if (!defaultCapacity.isUnknown())
+                {
                    while (buckets.size() > Math.ceil(psize.longValue() / defaultCapacity.longValue()))
+                   {
                       BucketEntry bucket = buckets.getLast();
                       if (bucket.bytesWritten != 0)
                          break;
                       buckets.remove(bucket);
+                   }
+                }
+             }
              currentDataIndex = psize.isUnknown() ? 0 : psize.intValue() - 1;
           }));
           // no-op in OE12.2
+       }
        /**
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void resizeArray(final integer _p1)
+       {
           integer p1 = TypeFactory.initInput(_p1);
           internalProcedure(this, "ResizeArray", new Block((Body) () -> {
              resize(p1);
           }));
           // no-op in oe12.2
+       }
        /**
-...
           long pos = p.longValue();
           long bytesLeft = data.lengthOf();
           int putAt = 0;
           int nbucket = (int) ((pos - 1) / defaultCapacity.longValue());
           int offset = (int) ((pos - 1) % defaultCapacity.longValue());
           int nbucket = (int) ((pos - 1) / MAX_BYTES_PER_ROW);
           int offset = (int) ((pos - 1) % MAX_BYTES_PER_ROW);
           int endBucket = (int) ((size.longValue()) / MAX_BYTES_PER_ROW);
           int endOffset = (int) ((size.longValue()) % MAX_BYTES_PER_ROW);
           for (int i = nbucket; i <= currentDataIndex; i++)
           for (int i = nbucket; i <= endBucket; i++)
+          {
              BucketEntry bucket = buckets.get(i);
              int numBytes = (int) Math.min(bucket.bytesWritten - offset, bytesLeft);
              byte[] bucket = buckets.get(i);
              int numBytes = (int) Math.min((i == endBucket ? endOffset : MAX_BYTES_PER_ROW) - offset, bytesLeft);
              if (numBytes > 0)
+             {
                 data.write(true, Arrays.copyOfRange(bucket.data, offset, offset + numBytes), putAt,
                 data.write(true, Arrays.copyOfRange(bucket, offset, offset + numBytes), putAt,
                          false);
                 offset = 0;
-...
+       {
           long bytesLeft = ptr.lengthOf();
           long startPos = 0;
           long bytesWritten = 0;
           while (bytesLeft > 0)
           while (bytesLeft > bytesWritten)
+          {
              long numBytes = Math.min(bytesLeft, Integer.MAX_VALUE);
              writeBytes(ptr.asByteArray(startPos, numBytes), (int) numBytes);
              startPos += numBytes;
              bytesLeft -= numBytes;
              numBytes = writeBytes(ptr.asByteArray(bytesWritten, numBytes), (int) numBytes);
              bytesWritten += numBytes;
+          }
           this.position.assign(this.position.longValue() + bytesWritten);
+       }
        private void writeBytes(byte[] data, int len)
        /**
         * Write the content of byte array.
+        *
         * The method updates the size but not the position because putBytes form ByteBucket does not
         * change the current position.
+        *
         * @param data the byte array data
         * @param len  the length of data to write
+        *
         * @return the number of bytes written
         */
        private int writeBytes(byte[] data, int len)
+       {
           int bytesLeft = Math.min(data.length, len);
           int startPos = 0;
           while (bytesLeft > 0)
+          {
              BucketEntry bucket;
              if (buckets.size() > currentDataIndex)
+             {
                 bucket = buckets.get(currentDataIndex);
+             }
              else
+             {
                 bucket = new BucketEntry();
                 buckets.add(bucket);
+             }
              int numBytes = Math.min(MAX_BYTES_PER_ROW - bucket.bytesWritten, bytesLeft);
              bytesLeft -= numBytes;
              if (numBytes > 0)
+             {
                 System.arraycopy(data, startPos, bucket.data, bucket.bytesWritten, numBytes);
                 bucket.bytesWritten += numBytes;
                 startPos += numBytes;
                 position.assign(this.position.longValue() + numBytes);
                 size.assign(this.size.longValue() + numBytes);
+             }
              if (bucket.bytesWritten == MAX_BYTES_PER_ROW)
+             {
                 currentDataIndex++;
+             }
+          }
+       }
        private static class BucketEntry
+       {
           public byte[] data;
           public int bytesWritten;
           BucketEntry()
+          {
              data = new byte[MAX_BYTES_PER_ROW];
              bytesWritten = 0;
+          }
+       }
           int bytesWritten = 0;
           int crtBucket = (int) (writePosition / MAX_BYTES_PER_ROW);
           int endBucket = (int) ((size.longValue()) / MAX_BYTES_PER_ROW);
           int endOffset = (int) ((size.longValue()) % MAX_BYTES_PER_ROW);
           if (writePosition + bytesLeft > Integer.MAX_VALUE)
+          {
              ErrorManager.recordOrThrowError(0,
                       "Cannot expand memory allocation because it exceeds the limit", false);
              return 0;
+          }
           else
+          {
              while (bytesLeft > 0)
+             {
                 byte[] bucket;
                 if (buckets.size() > crtBucket)
+                {
                    bucket = buckets.get(crtBucket);
+                }
                 else
+                {
                    bucket = new byte[MAX_BYTES_PER_ROW];
                    buckets.add(bucket);
+                }
                 int pos = crtBucket == endBucket ? endOffset : 0;
                 int numBytes = Math.min(MAX_BYTES_PER_ROW - pos, bytesLeft);
                 bytesLeft -= numBytes;
                 if (numBytes > 0)
+                {
                    System.arraycopy(data, bytesWritten, bucket, pos, numBytes);
                    bytesWritten += numBytes;
+                }
                 crtBucket++;
+             }
              writePosition += bytesWritten;
              size.assign(this.size.longValue() + bytesWritten);
              return bytesWritten;
+          }
+       }
+    }

     ** -#- -I- --Date-- -------------------------------Description--------------------------------
     ** 001 ME  20200324 Created the first version, by converting the legacy skeleton .cls file and
     **                  using that output.
     ** 002 ME  20201023 Added implementation for isType, notType.
     */
     /*
-...
                 @LegacyParameter(name = "p1", type = "HANDLE", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "OBJECT", qualified = "openedge.core.datatypeenum", mode = "INPUT"),
                 @LegacyParameter(name = "p3", type = "CHARACTER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void isType(final handle _p1,
                 final object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> _p2,
                 final character _p3)
-...
           object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> p2 = TypeFactory.initInput(_p2);
           character p3 = TypeFactory.initInput(_p3);
           internalProcedure(AssertObject.class, "IsType", new Block());
           internalProcedure(AssertObject.class, "IsType", new Block((Body) () -> {
              Assert.notNull(p1, p3);
              notNull(p2, new character("Check DataType"));
              if (!p1.isType(p2.ref().toLegacyString().getValue()))
                 returnError(ObjectOps.newInstance(AssertionFailedError.class, "II",
                          substitute("&1 is not of type &2", p3, p2), 0));
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "IsType", parameters = {
-...
                 @LegacyParameter(name = "p1", type = "HANDLE", mode = "INPUT"),
                 @LegacyParameter(name = "p2", type = "OBJECT", qualified = "openedge.core.datatypeenum", mode = "INPUT"),
                 @LegacyParameter(name = "p3", type = "CHARACTER", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void notType(final handle _p1,
                 final object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> _p2,
                 final character _p3)
-...
           object<? extends com.goldencode.p2j.oo.core.DataTypeEnum> p2 = TypeFactory.initInput(_p2);
           character p3 = TypeFactory.initInput(_p3);
           internalProcedure(AssertObject.class, "NotType", new Block());
           internalProcedure(AssertObject.class, "NotType", new Block((Body) () -> {
              Assert.notNull(p1, p3);
              notNull(p2, new character("Check DataType"));
              if (p1.isType(p2.ref().toLegacyString().getValue()))
                 returnError(ObjectOps.newInstance(AssertionFailedError.class, "II",
                          substitute("&1 cannot be of type &2", p3, p2), 0));
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "NotType", parameters = {
-...
        @LegacySignature(type = Type.METHOD, name = "IsSerializable", parameters = {
                 @LegacyParameter(name = "p1", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void isSerializable(
                 final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> _p1)
+       {
           ObjectOps.load(AssertObject.class);
           object<? extends com.goldencode.p2j.oo.lang._BaseObject_> p1 = TypeFactory.initInput(_p1);
           internalProcedure(AssertObject.class, "IsSerializable", new Block());
           // TODO: add serializable in progress.lang.class (LegacyClass)
           internalProcedure(AssertObject.class, "IsSerializable", new Block((Body) () -> {
              Assert.notNull(p1, new character("argument"));
              object<? extends LegacyClass> cls = LegacyClass.getLegacyClass(p1);
              if (!cls.ref().isSerializable().booleanValue())
                 returnError(ObjectOps.newInstance(AssertionFailedError.class, "II",
                          substitute("Object &1 (of type &2) is not serializable", p1.ref().toLegacyString(), cls.ref().getTypeName()), 0));
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "NotSerializable", parameters = {
                 @LegacyParameter(name = "p1", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_STUB)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public static void notSerializable(
                 final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> _p1)
+       {
           ObjectOps.load(AssertObject.class);
           object<? extends com.goldencode.p2j.oo.lang._BaseObject_> p1 = TypeFactory.initInput(_p1);
           internalProcedure(AssertObject.class, "NotSerializable", new Block());
           // TODO: add serializable in progress.lang.class (LegacyClass)
           internalProcedure(AssertObject.class, "NotSerializable", new Block((Body) () -> {
              Assert.notNull(p1, new character("argument"));
              object<? extends LegacyClass> cls = LegacyClass.getLegacyClass(p1);
              if (cls.ref().isSerializable().booleanValue())
                 returnError(ObjectOps.newInstance(AssertionFailedError.class, "II",
                          substitute("Object &1 (of type &2) is serializable", p1.ref().toLegacyString(), cls.ref().getTypeName()), 0));
           }));
+       }
+    }

     ** 001 ME  20200514 First version, stubs taken by converting the skeleton using FWD.
     ** 002 CA  20210113 Renamed Iiterator.next to Iiterator.next_, to follow NameConverter's rules.
     **         20210113 Renamed clear() to clear_(), to follow NameConverter's rules.
     ** 003 ME  20210128 Keep only the default 4GL temp-table implementation.
     */
     /*
-...
     import com.goldencode.p2j.util.BlockManager.Action;
     import com.goldencode.p2j.util.BlockManager.Condition;
     import edu.emory.mathcs.backport.java.util.Arrays;
     import com.goldencode.p2j.oo.core.Assert;
     import com.goldencode.p2j.oo.core.collections.Icollection;
     import com.goldencode.p2j.oo.lang.*;
-...
     import static com.goldencode.p2j.util.BlockManager.*;
     import static com.goldencode.p2j.util.InternalEntry.Type;
     import java.util.ArrayList;
     import java.util.Collection;
     import java.util.Collections;
     /**
      * Business logic (converted to Java from the 4GL source code
      * in OpenEdge/Core/Collections/AbstractTTCollection.cls).
-...
        private handle fieldHandle = TypeFactory.handle();
        private handle queryHandle = TypeFactory.handle();
        private Collection<object<? extends _BaseObject_>> objects;
        public void __core_collections_AbstractTtcollection_execute__()
+       {
           externalProcedure(AbstractTtcollection.class, AbstractTtcollection.this,
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public integer getSize()
+       {
           return function(AbstractTtcollection.class, this, "Size", integer.class,
                    new Block((Body) () ->
+                   {
                       returnNormal(size);
                    }));
           return function(this, "Size", integer.class, new Block((Body) () -> {
              returnNormal(size);
           }));
+       }
        @LegacySignature(type = Type.CONSTRUCTOR)
-...
                    "__core_collections_AbstractTtcollection_constructor__", new Block((Body) () ->
+                   {
                       __lang_BaseObject_constructor__();
                       // use a java collection by default
                       objects = new ArrayList<object<? extends _BaseObject_>>();
                    }));
+       }
-...
                 final character _p2)
+       {
           internalProcedure(AbstractTtcollection.class, this,
                    "__core_collections_AbstractTtcollection_constructor__", new Block((Body) () ->
+                   {
                       __core_collections_AbstractTtcollection_constructor__(_p1,
                                _p1.isType(LegacyResource.TEMP_TABLE)
                                         ? _p1.unwrapTempTable().defaultBufferHandle().unwrapBuffer()
                                                  .bufferField(_p2)
                                         : new handle());
                    "__core_collections_AbstractTtcollection_constructor__", new Block((Body) () -> {
                       __core_collections_AbstractTtcollection_constructor__(_p1, _p1.unwrapTempTable()
                                .defaultBufferHandle().unwrapBuffer().bufferField(_p2));
                    }));
+       }
-...
                       __lang_BaseObject_constructor__();
                       size.assign(0);
                       // default 4GL temp-table implementation
                       if (p1.isType(LegacyResource.TEMP_TABLE))
+                      {
                          tableHandle.assign(p1);
                          fieldHandle.assign(p2);
                          objects = Collections.EMPTY_LIST;
+                      }
                       // java map implementation
                       else
+                      {
                          objects = new ArrayList<object<? extends _BaseObject_>>();
+                      }
                       tableHandle.assign(p1.unwrapTempTable());
                       fieldHandle.assign(p2);
                    }));
+       }
-...
+       {
           object<? extends _BaseObject_> p1 = TypeFactory.initInput(_p1);
           return function(AbstractTtcollection.class, this, "Add", logical.class,
                    new Block((Body) () ->
+                   {
                       boolean result = false;
                       if (p1._isValid())
+                      {
                          if (objects == Collections.EMPTY_LIST)
+                         {
                             Buffer buffer = tableHandle.unwrapTempTable().defaultBufferHandle()
                                      .unwrapBuffer();
                             buffer.bufferCreate();
                             fieldHandle.unwrapBufferField().changeValue(p1);
                             buffer.bufferRelease();
                             result = true;
+                         }
                          else
+                         {
                             result = objects.add(p1);
+                         }
+                      }
                       if (result)
                          size.assign(size.intValue() + 1);
                       returnNormal(result);
                    }));
           return function(this, "Add", logical.class, new Block((Body) () -> {
              if (p1._isValid())
+             {
                    Buffer buffer = tableHandle.unwrapTempTable().defaultBufferHandle().unwrapBuffer();
                    buffer.bufferCreate();
                    fieldHandle.unwrapBufferField().changeValue(p1);
                    buffer.bufferRelease();
                    size.assign(size.intValue() + 1);
                    returnNormal(true);
+             }
              returnNormal(false);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "AddArray", parameters = {
-...
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public logical addArray(final object<? extends _BaseObject_>[] _p1)
+       {
           object<? extends _BaseObject_>[] p1[] = new object[][] { TypeFactory.initInput(_p1) };
           return function(AbstractTtcollection.class, this, "AddArray", logical.class,
                    new Block((Body) () ->
+                   {
                       if (p1[0].length > 0)
+                      {
                          if (objects == Collections.EMPTY_LIST)
+                         {
                             for (int i = 0; i < p1.length; i++)
+                            {
                                add(p1[0][i]);
+                            }
+                         }
                          else
+                         {
                             objects.addAll(Arrays.asList(p1[0]));
                             size.assign(size.intValue() + p1[0].length);
+                         }
+                      }
                       returnNormal(true);
                    }));
           object<? extends _BaseObject_> p1[] = TypeFactory.initInput(_p1);
           return function(this, "AddArray", logical.class, new Block((Body) () -> {
              if (p1.length > 0)
+             {
                 for (int i = 0; i < p1.length; i++)
+                {
                    add(p1[i]);
+                }
+             }
              returnNormal(true);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "AddAll", parameters = {
-...
+       {
           object<? extends Icollection> p1 = TypeFactory.initInput(_p1);
           return function(AbstractTtcollection.class, this, "AddAll", logical.class,
                    new Block((Body) () ->
+                   {
                       if (objects == Collections.EMPTY_LIST && getLegacyClass().ref()
                                .legacyEquals(p1.ref().getLegacyClass()).booleanValue())
+                      {
                          p1.ref().toTable(new TableParameter(tableHandle, true));
                          size.assign(size.intValue() + p1.ref().getSize().intValue());
+                      }
                       else
+                      {
                          Iiterator it = p1.ref().iterator().ref();
                          while (it.hasNext().booleanValue())
+                         {
                             add(it.next_());
+                         }
+                      }
                       returnNormal(true);
                    }));
           return function(this, "AddAll", logical.class, new Block((Body) () -> {
              if (getLegacyClass().ref()
                       .legacyEquals(p1.ref().getLegacyClass()).booleanValue())
+             {
                 p1.ref().toTable(new TableParameter(tableHandle, true));
                 size.assign(size.intValue() + p1.ref().getSize().intValue());
+             }
              else
+             {
                 Iiterator it = p1.ref().iterator().ref();
                 while (it.hasNext().booleanValue())
+                {
                    add(it.next_());
+                }
+             }
              returnNormal(true);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "Clear")
-...
+       {
           internalProcedure(AbstractTtcollection.class, this, "Clear", new Block((Body) () ->
+          {
              if (objects == Collections.EMPTY_LIST)
+             {
                 tableHandle.unwrapTempTable().deleteAll();
+             }
              else
+             {
                 objects.clear();
+             }
              tableHandle.unwrapTempTable().deleteAll();
              size.assign(0);
           }));
+       }
-...
+       {
           object<? extends _BaseObject_> p1 = TypeFactory.initInput(_p1);
           return function(AbstractTtcollection.class, this, "Contains", logical.class,
                    new Block((Body) () ->
+                   {
                       if (objects == Collections.EMPTY_LIST)
+                      {
                          findBufferUseObject(p1);
                          returnNormal(tableHandle.unwrapTempTable().defaultBufferHandle()
                                   .unwrapBuffer().available());
+                      }
                       else
+                      {
                          returnNormal(objects.contains(p1));
+                      }
                    }));
           return function(this, "Contains", logical.class, new Block((Body) () -> {
              findBufferUseObject(p1);
              returnNormal(tableHandle.unwrapTempTable().defaultBufferHandle().unwrapBuffer()
                       .available());
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "ContainsAll", parameters = {
-...
+       {
           object<? extends Icollection> p1 = TypeFactory.initInput(_p1);
           return function(AbstractTtcollection.class, this, "ContainsAll", logical.class,
                    new Block((Body) () ->
+                   {
                       Assert.notNull(p1, new character("Collection to check"));
                       if (p1.ref().isEmpty().booleanValue())
                          returnNormal(true);
                       // this is handled like a set not collection
                       if (p1.ref().getSize().intValue() > size.intValue())
                          returnNormal(false);
                       Iiterator it = p1.ref().iterator().ref();
                       while (it.hasNext().booleanValue())
+                      {
                          if (!contains(it.next_()).booleanValue())
                             returnNormal(false);
+                      }
                       returnNormal(true);
                    }));
           return function(this, "ContainsAll", logical.class, new Block((Body) () -> {
              Assert.notNull(p1, new character("Collection to check"));
              if (p1.ref().isEmpty().booleanValue())
                 returnNormal(true);
              // this is handled like a set not collection
              if (p1.ref().getSize().intValue() > size.intValue())
                 returnNormal(false);
              Iiterator it = p1.ref().iterator().ref();
              while (it.hasNext().booleanValue())
+             {
                 if (!contains(it.next_()).booleanValue())
                    returnNormal(false);
+             }
              returnNormal(true);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "Iterator", qualified = "openedge.core.collections.iiterator")
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public object<? extends com.goldencode.p2j.oo.core.collections.Iiterator> iterator()
+       {
           return function(AbstractTtcollection.class, this, "Iterator", object.class,
                    new Block((Body) () ->
+                   {
                       if (objects == Collections.EMPTY_LIST)
+                      {
                          returnNormal(ObjectOps.newInstance(LegacyIterator.class, "III",
                                   new object(this), tableHandle, fieldHandle.unwrap().name()));
+                      }
                       else
+                      {
                          returnNormal(ObjectOps.newInstance(LegacyIterator.class, "III",
                                   new object(this), new handle(new TransparentWrapper(objects)), ""));
+                      }
                    }));
           return function(this, "Iterator", object.class, new Block((Body) () -> {
              returnNormal(ObjectOps.newInstance(LegacyIterator.class, "III", new object(this),
                       tableHandle, fieldHandle.unwrap().name()));
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "IsEmpty")
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public logical isEmpty()
+       {
           return function(AbstractTtcollection.class, this, "IsEmpty", logical.class,
                    new Block((Body) () ->
+                   {
                       if (objects == Collections.EMPTY_LIST)
+                      {
                          returnNormal(!tableHandle.unwrapTempTable().hasRecords().booleanValue());
+                      }
                       else
+                      {
                          returnNormal(objects.isEmpty());
+                      }
                    }));
           return function(this, "IsEmpty", logical.class, new Block((Body) () -> {
              returnNormal(!tableHandle.unwrapTempTable().hasRecords().booleanValue());
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "ToTable", parameters = {
                 @LegacyParameter(name = "p1", type = "HANDLE", mode = "OUTPUT") })
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_PARTIAL)
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public void toTable(final TableParameter _p1)
+       {
           handle p1 = new handle();
-...
              TypeFactory.initOutput(p1);
           }, (Body) () ->
+          {
              if (objects == Collections.EMPTY_LIST)
+             {
                 TemporaryBuffer.createDynamicTable(_p1, p1, false, true);
                 p1.assign(tableHandle);
+             }
              // TODO: create table from collection
              else
+             {
+             }
              TemporaryBuffer.createDynamicTable(_p1, p1, false, true);
              p1.assign(tableHandle);
           }));
+       }
-...
+       {
           object<? extends _BaseObject_> p1 = TypeFactory.initInput(_p1);
           return function(AbstractTtcollection.class, this, "Remove", logical.class,
                    new Block((Body) () ->
           return function(this, "Remove", logical.class, new Block((Body) () -> {
              boolean result = false;
              if (p1._isValid())
+             {
                    findBufferUseObject(p1);
                    Buffer buffer = tableHandle.unwrapTempTable().defaultBufferHandle().unwrapBuffer();
                    if (buffer._available())
+                   {
                       boolean result = false;
                       if (p1._isValid())
+                      {
                          if (objects == Collections.EMPTY_LIST)
+                         {
                             findBufferUseObject(p1);
                             Buffer buffer = tableHandle.unwrapTempTable().defaultBufferHandle()
                                      .unwrapBuffer();
                             if (buffer._available())
+                            {
                                buffer.deleteRecord();
                                result = true;
+                            }
+                         }
                          else
+                         {
                             result = objects.remove(p1);
+                         }
+                      }
                       if (result)
                          size.assign(size.intValue() - 1);
                       returnNormal(result);
                    }));
                       buffer.deleteRecord();
                       result = true;
+                   }
+             }
              if (result)
                 size.assign(size.intValue() - 1);
              returnNormal(result);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "RemoveAll", parameters = {
-...
+       {
           object<? extends Icollection> p1 = TypeFactory.initInput(_p1);
           return function(AbstractTtcollection.class, this, "RemoveAll", logical.class,
                    new Block((Body) () ->
+                   {
                       boolean result = false;
                       Iiterator it = p1.ref().iterator().ref();
                       while (it.hasNext().booleanValue())
+                      {
                          object<? extends _BaseObject_> obj = it.next_();
                          while (remove(obj).booleanValue())
                             result = true;
+                      }
                       returnNormal(result);
                    }));
           return function(this, "RemoveAll", logical.class, new Block((Body) () -> {
              boolean result = false;
              Iiterator it = p1.ref().iterator().ref();
              while (it.hasNext().booleanValue())
+             {
                 object<? extends _BaseObject_> obj = it.next_();
                 while (remove(obj).booleanValue())
                    result = true;
+             }
              returnNormal(result);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "RetainAll", parameters = {
-...
+       {
           object<? extends Icollection> p1 = TypeFactory.initInput(_p1);
           return function(AbstractTtcollection.class, this, "RetainAll", logical.class,
                    new Block((Body) () ->
+                   {
                       boolean result = false;
                       Iiterator it = iterator().ref();
                       while (it.hasNext().booleanValue())
+                      {
                          object<? extends _BaseObject_> obj = it.next_();
                          if (!p1.ref().contains(obj).booleanValue())
+                         {
                             while (remove(obj).booleanValue())
                                result = true;
+                         }
+                      }
                       returnNormal(result);
                    }));
           return function(this, "RetainAll", logical.class, new Block((Body) () -> {
              boolean result = false;
              Iiterator it = iterator().ref();
              while (it.hasNext().booleanValue())
+             {
                 object<? extends _BaseObject_> obj = it.next_();
                 if (!p1.ref().contains(obj).booleanValue())
+                {
                    while (remove(obj).booleanValue())
                       result = true;
+                }
+             }
              returnNormal(result);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "ToArray", extent = -1, qualified = "progress.lang.object")
        @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
        public object<? extends com.goldencode.p2j.oo.lang._BaseObject_>[] toArray()
+       {
           return extentFunction(AbstractTtcollection.class, this, "ToArray", object.class,
                    new Block((Body) () ->
+                   {
                       if (objects == Collections.EMPTY_LIST)
+                      {
                          if (isEmpty().booleanValue())
                             returnExtentNormal(new object[0]);
                          else
+                         {
                             object<? extends _BaseObject_> oArr[] = TypeFactory
                                      .objectExtent(getSize().intValue(), BaseObject.class);
                             Iiterator it = iterator().ref();
                             int i = 0;
           return extentFunction(this, "ToArray", object.class, new Block((Body) () -> {
              if (isEmpty().booleanValue())
                 returnExtentNormal(new object[0]);
              else
+             {
                 object<? extends _BaseObject_> oArr[] = TypeFactory
                          .objectExtent(getSize().intValue(), BaseObject.class);
                 Iiterator it = iterator().ref();
                 int i = 0;
                             while (it.hasNext().booleanValue())
+                            {
                                oArr[i++].assign(it.next_());
+                            }
                             returnExtentNormal(oArr);
+                         }
+                      }
                       else
+                      {
                          returnExtentNormal(objects.toArray(new object[objects.size()]));
+                      }
                    }));
                 while (it.hasNext().booleanValue())
+                {
                    oArr[i++].assign(it.next_());
+                }
                 returnExtentNormal(oArr);
+             }
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "FindBufferUseObject", parameters = {
-...
        @Override
        public object<? extends com.goldencode.p2j.oo.lang._BaseObject_> clone()
+       {
           return function(AbstractTtcollection.class, this, "Clone", object.class,
                    new Block((Body) () ->
+                   {
                       object<AbstractTtcollection> clone = ObjectOps
                                .newInstance(AbstractTtcollection.class);
                       cloneElements(clone);
                       returnNormal(clone);
                    }));
           return function(this, "Clone", object.class, new Block((Body) () -> {
              object<? extends AbstractTtcollection> clone = ObjectOps.newInstance(getClass());
              cloneElements(clone);
              returnNormal(clone);
           }));
+       }
        @LegacySignature(type = Type.METHOD, name = "CloneElements", parameters = {
-...
+       {
           internalProcedure(AbstractTtcollection.class, this, "Resize", new Block((Body) () ->
+          {
              if (objects == Collections.EMPTY_LIST)
+             {
                 if (!queryHandle._isValid()) {
                    QueryWrapper.createQuery(queryHandle);
                    queryHandle.unwrapBufferCollection().setBuffers(tableHandle.unwrapTempTable().defaultBufferHandle());
                    queryHandle.unwrapQuery().prepare(String.format("preselect each %s no-lock", tableHandle.unwrap().name()));
+                }
                 queryHandle.unwrapQuery().open();

... This diff was truncated because it exceeds the maximum size that can be displayed.

Project

General

Profile

FWD » Core Development » Base Language

3821c.4384g.patch