* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.serialize.codecs.stdlib

import org.gradle.api.internal.GeneratedSubclasses.unpackType
import org.gradle.internal.serialize.graph.logUnsupportedBaseType
import org.gradle.internal.configuration.problems.StructuredMessageBuilder
import org.gradle.internal.serialize.graph.Codec

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.serialize.graph

import org.gradle.api.internal.GeneratedSubclasses.unpackType
import org.gradle.internal.configuration.problems.DocumentationSection
import org.gradle.internal.configuration.problems.StructuredMessageBuilder


inline fun <reified T : Any> unsupported(

 * limitations under the License.
 */

package org.gradle.internal.serialize.codecs.core

import org.gradle.api.Task
import org.gradle.api.internal.GeneratedSubclasses.unpackType
import org.gradle.api.internal.tasks.TaskContainerInternal
import org.gradle.internal.cc.base.serialize.IsolateOwners
import org.gradle.internal.serialize.graph.logUnsupportedBaseType

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.serialize.graph

import org.gradle.api.internal.GeneratedSubclasses.unpackType
import org.gradle.internal.configuration.problems.DocumentationSection
import org.gradle.internal.configuration.problems.DocumentationSection.NotYetImplemented

                @Override
                public boolean apply(Plugin plugin) {
                    Class<?> pluginType = GeneratedSubclasses.unpackType(plugin);
                    return pluginWithId.clazz.equals(pluginType);
                }
            }).orNull();

            if (plugin != null) {
                return plugin;
            }
        }

            return uncheckedCast(((HasPublicType) object).getPublicType());
        }
        return TypeOf.<Object>typeOf(GeneratedSubclasses.unpackType(object));
    }

    public Class<?> getImplementationType() {
        return GeneratedSubclasses.unpackType(object);
    }

    private static <T> T toType(Object delegate, Class<T> type) {
        if (type.isInstance(delegate)) {

            } catch (Exception e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
        return type;
    }

    public static Class<?> unpackType(Object object) {
        if (object instanceof GeneratedSubclass) {
            return ((GeneratedSubclass) object).publicType();
        }
        return object.getClass();
    }

import org.gradle.internal.serialize.graph.logNotImplemented


object NotImplementedCodec : Codec<Any> {

    override suspend fun WriteContext.encode(value: Any) {
        val javaClass = GeneratedSubclasses.unpackType(value)
        writeClass(javaClass)
        logNotImplemented(javaClass)
    }

    override suspend fun ReadContext.decode(): Any? {
        logNotImplemented(readClass())
        return null
    }

object BeanCodec : Codec<Any> {

    override suspend fun WriteContext.encode(value: Any) {
        encodePreservingIdentityOf(value) {
            val beanType = GeneratedSubclasses.unpackType(value)
            withBeanTrace(beanType) {
                writeBeanOf(beanType, value)
            }
        }
    }

    override suspend fun ReadContext.decode(): Any =

            onError(error) {
                when {
                    value != null -> {
                        text("error writing value of type ")
                        reference(GeneratedSubclasses.unpackType(value))
                    }

                    else -> {
                        text("error writing null value")
                    }
                }
            }
        }
    }
}