redesign nClass so that compiled inherits from uncompiled, C components are contained in private, and packaged names can be managed

[perrydv]

This PR makes some big changes to how nClasses are organized internally.

1. Previously a compiled nClass was given copies of the uncompiled methods and then was a stand-alone class. Now a compiled nClass inherits from the uncompiled. That means S3 method dispatch or other logic using the "class" attribute can be written to handle either or both. In fact the compiled version is nearly identical to the uncompiled, with the difference that that isCompiled() method returns TRUE instead of FALSE.

2. Previously Cpublic methods were built into the R6Class in the same way as Rpublic methods. Now there is a private$Cpublic_obj with those methods and there are corresponding methods in the R6Class that simply call the private$Cpublic_obj versions. This has the advantage that uncompiled and compiled versions of the R6Class can now be nearly identical, simply with different classes for the private$Cpublic_obj. (Note that even the uncompiled version has a Cpublic_obj, which is the uncompiled version of the Cpublic contents.) Another advantage is more similar uncompiled and compiled behavior: Now in both cases, Cpublic methods will not see Rpublic fields or methods (previously, the uncompiled case would see them "by accident"). A cost is additional method calling overhead, but we think this will be minor.

3. Now there is finer control available over names used in generated package code with the compileInfo element packageNames, which can have elements named compiled and uncompiled. These are distinct from both classname and exportName. This is all necessary because in the case of nClass inheritance (i.e. using the inherit argument), the name (or other code) used to find the base class must work and so that base class name must not change in generated package code. A result of the above changes and this need was a real hassle of additional naming logic to try to make things "just work" in simple cases but provide full control where needed.

This effort became bogged down in some cases but should be ready to go now. Some merge conflicts will need to be investigated.

[perrydv]

This PR makes some big changes to how nClasses are organized internally.

1. Previously a compiled nClass was given copies of the uncompiled methods and then was a stand-alone class. Now a compiled nClass inherits from the uncompiled. That means S3 method dispatch or other logic using the "class" attribute can be written to handle either or both. In fact the compiled version is nearly identical to the uncompiled, with the difference that that isCompiled() method returns TRUE instead of FALSE.

2. Previously Cpublic methods were built into the R6Class in the same way as Rpublic methods. Now there is a private$Cpublic_obj with those methods and there are corresponding methods in the R6Class that simply call the private$Cpublic_obj versions. This has the advantage that uncompiled and compiled versions of the R6Class can now be nearly identical, simply with different classes for the private$Cpublic_obj. (Note that even the uncompiled version has a Cpublic_obj, which is the uncompiled version of the Cpublic contents.) Another advantage is more similar uncompiled and compiled behavior: Now in both cases, Cpublic methods will not see Rpublic fields or methods (previously, the uncompiled case would see them "by accident"). A cost is additional method calling overhead, but we think this will be minor.

3. Now there is finer control available over names used in generated package code with the compileInfo element packageNames, which can have elements named compiled and uncompiled. These are distinct from both classname and exportName. This is all necessary because in the case of nClass inheritance (i.e. using the inherit argument), the name (or other code) used to find the base class must work and so that base class name must not change in generated package code. A result of the above changes and this need was a real hassle of additional naming logic to try to make things "just work" in simple cases but provide full control where needed.

This effort became bogged down in some cases but should be ready to go now. Some merge conflicts will need to be investigated.

[perrydv]

This PR makes some big changes to how nClasses are organized internally.

1. Previously a compiled nClass was given copies of the uncompiled methods and then was a stand-alone class. Now a compiled nClass inherits from the uncompiled. That means S3 method dispatch or other logic using the "class" attribute can be written to handle either or both. In fact the compiled version is nearly identical to the uncompiled, with the difference that that isCompiled() method returns TRUE instead of FALSE.

2. Previously Cpublic methods were built into the R6Class in the same way as Rpublic methods. Now there is a private$Cpublic_obj with those methods and there are corresponding methods in the R6Class that simply call the private$Cpublic_obj versions. This has the advantage that uncompiled and compiled versions of the R6Class can now be nearly identical, simply with different classes for the private$Cpublic_obj. (Note that even the uncompiled version has a Cpublic_obj, which is the uncompiled version of the Cpublic contents.) Another advantage is more similar uncompiled and compiled behavior: Now in both cases, Cpublic methods will not see Rpublic fields or methods (previously, the uncompiled case would see them "by accident"). A cost is additional method calling overhead, but we think this will be minor.

3. Now there is finer control available over names used in generated package code with the compileInfo element packageNames, which can have elements named compiled and uncompiled. These are distinct from both classname and exportName. This is all necessary because in the case of nClass inheritance (i.e. using the inherit argument), the name (or other code) used to find the base class must work and so that base class name must not change in generated package code. A result of the above changes and this need was a real hassle of additional naming logic to try to make things "just work" in simple cases but provide full control where needed.

This effort became bogged down in some cases but should be ready to go now. Some merge conflicts will need to be investigated.

[perrydv]

This PR makes some big changes to how nClasses are organized internally.

1. Previously a compiled nClass was given copies of the uncompiled methods and then was a stand-alone class. Now a compiled nClass inherits from the uncompiled. That means S3 method dispatch or other logic using the "class" attribute can be written to handle either or both. In fact the compiled version is nearly identical to the uncompiled, with the difference that that isCompiled() method returns TRUE instead of FALSE.

2. Previously Cpublic methods were built into the R6Class in the same way as Rpublic methods. Now there is a private$Cpublic_obj with those methods and there are corresponding methods in the R6Class that simply call the private$Cpublic_obj versions. This has the advantage that uncompiled and compiled versions of the R6Class can now be nearly identical, simply with different classes for the private$Cpublic_obj. (Note that even the uncompiled version has a Cpublic_obj, which is the uncompiled version of the Cpublic contents.) Another advantage is more similar uncompiled and compiled behavior: Now in both cases, Cpublic methods will not see Rpublic fields or methods (previously, the uncompiled case would see them "by accident"). A cost is additional method calling overhead, but we think this will be minor.

3. Now there is finer control available over names used in generated package code with the compileInfo element packageNames, which can have elements named compiled and uncompiled. These are distinct from both classname and exportName. This is all necessary because in the case of nClass inheritance (i.e. using the inherit argument), the name (or other code) used to find the base class must work and so that base class name must not change in generated package code. A result of the above changes and this need was a real hassle of additional naming logic to try to make things "just work" in simple cases but provide full control where needed.

This effort became bogged down in some cases but should be ready to go now. Some merge conflicts will need to be investigated.

[perrydv]

This PR makes some big changes to how nClasses are organized internally.

1. Previously a compiled nClass was given copies of the uncompiled methods and then was a stand-alone class. Now a compiled nClass inherits from the uncompiled. That means S3 method dispatch or other logic using the "class" attribute can be written to handle either or both. In fact the compiled version is nearly identical to the uncompiled, with the difference that that isCompiled() method returns TRUE instead of FALSE.

2. Previously Cpublic methods were built into the R6Class in the same way as Rpublic methods. Now there is a private$Cpublic_obj with those methods and there are corresponding methods in the R6Class that simply call the private$Cpublic_obj versions. This has the advantage that uncompiled and compiled versions of the R6Class can now be nearly identical, simply with different classes for the private$Cpublic_obj. (Note that even the uncompiled version has a Cpublic_obj, which is the uncompiled version of the Cpublic contents.) Another advantage is more similar uncompiled and compiled behavior: Now in both cases, Cpublic methods will not see Rpublic fields or methods (previously, the uncompiled case would see them "by accident"). A cost is additional method calling overhead, but we think this will be minor.

3. Now there is finer control available over names used in generated package code with the compileInfo element packageNames, which can have elements named compiled and uncompiled. These are distinct from both classname and exportName. This is all necessary because in the case of nClass inheritance (i.e. using the inherit argument), the name (or other code) used to find the base class must work and so that base class name must not change in generated package code. A result of the above changes and this need was a real hassle of additional naming logic to try to make things "just work" in simple cases but provide full control where needed.

This effort became bogged down in some cases but should be ready to go now. Some merge conflicts will need to be investigated.

[perrydv]

This PR makes some big changes to how nClasses are organized internally.

1. Previously a compiled nClass was given copies of the uncompiled methods and then was a stand-alone class. Now a compiled nClass inherits from the uncompiled. That means S3 method dispatch or other logic using the "class" attribute can be written to handle either or both. In fact the compiled version is nearly identical to the uncompiled, with the difference that that isCompiled() method returns TRUE instead of FALSE.

2. Previously Cpublic methods were built into the R6Class in the same way as Rpublic methods. Now there is a private$Cpublic_obj with those methods and there are corresponding methods in the R6Class that simply call the private$Cpublic_obj versions. This has the advantage that uncompiled and compiled versions of the R6Class can now be nearly identical, simply with different classes for the private$Cpublic_obj. (Note that even the uncompiled version has a Cpublic_obj, which is the uncompiled version of the Cpublic contents.) Another advantage is more similar uncompiled and compiled behavior: Now in both cases, Cpublic methods will not see Rpublic fields or methods (previously, the uncompiled case would see them "by accident"). A cost is additional method calling overhead, but we think this will be minor.

3. Now there is finer control available over names used in generated package code with the compileInfo element packageNames, which can have elements named compiled and uncompiled. These are distinct from both classname and exportName. This is all necessary because in the case of nClass inheritance (i.e. using the inherit argument), the name (or other code) used to find the base class must work and so that base class name must not change in generated package code. A result of the above changes and this need was a real hassle of additional naming logic to try to make things "just work" in simple cases but provide full control where needed.

This effort became bogged down in some cases but should be ready to go now. Some merge conflicts will need to be investigated.

[perrydv]

This PR makes some big changes to how nClasses are organized internally.

1. Previously a compiled nClass was given copies of the uncompiled methods and then was a stand-alone class. Now a compiled nClass inherits from the uncompiled. That means S3 method dispatch or other logic using the "class" attribute can be written to handle either or both. In fact the compiled version is nearly identical to the uncompiled, with the difference that that isCompiled() method returns TRUE instead of FALSE.

2. Previously Cpublic methods were built into the R6Class in the same way as Rpublic methods. Now there is a private$Cpublic_obj with those methods and there are corresponding methods in the R6Class that simply call the private$Cpublic_obj versions. This has the advantage that uncompiled and compiled versions of the R6Class can now be nearly identical, simply with different classes for the private$Cpublic_obj. (Note that even the uncompiled version has a Cpublic_obj, which is the uncompiled version of the Cpublic contents.) Another advantage is more similar uncompiled and compiled behavior: Now in both cases, Cpublic methods will not see Rpublic fields or methods (previously, the uncompiled case would see them "by accident"). A cost is additional method calling overhead, but we think this will be minor.

3. Now there is finer control available over names used in generated package code with the compileInfo element packageNames, which can have elements named compiled and uncompiled. These are distinct from both classname and exportName. This is all necessary because in the case of nClass inheritance (i.e. using the inherit argument), the name (or other code) used to find the base class must work and so that base class name must not change in generated package code. A result of the above changes and this need was a real hassle of additional naming logic to try to make things "just work" in simple cases but provide full control where needed.

This effort became bogged down in some cases but should be ready to go now. Some merge conflicts will need to be investigated.

[perrydv]

This PR makes some big changes to how nClasses are organized internally.

1. Previously a compiled nClass was given copies of the uncompiled methods and then was a stand-alone class. Now a compiled nClass inherits from the uncompiled. That means S3 method dispatch or other logic using the "class" attribute can be written to handle either or both. In fact the compiled version is nearly identical to the uncompiled, with the difference that that isCompiled() method returns TRUE instead of FALSE.

2. Previously Cpublic methods were built into the R6Class in the same way as Rpublic methods. Now there is a private$Cpublic_obj with those methods and there are corresponding methods in the R6Class that simply call the private$Cpublic_obj versions. This has the advantage that uncompiled and compiled versions of the R6Class can now be nearly identical, simply with different classes for the private$Cpublic_obj. (Note that even the uncompiled version has a Cpublic_obj, which is the uncompiled version of the Cpublic contents.) Another advantage is more similar uncompiled and compiled behavior: Now in both cases, Cpublic methods will not see Rpublic fields or methods (previously, the uncompiled case would see them "by accident"). A cost is additional method calling overhead, but we think this will be minor.

3. Now there is finer control available over names used in generated package code with the compileInfo element packageNames, which can have elements named compiled and uncompiled. These are distinct from both classname and exportName. This is all necessary because in the case of nClass inheritance (i.e. using the inherit argument), the name (or other code) used to find the base class must work and so that base class name must not change in generated package code. A result of the above changes and this need was a real hassle of additional naming logic to try to make things "just work" in simple cases but provide full control where needed.

This effort became bogged down in some cases but should be ready to go now. Some merge conflicts will need to be investigated.