/*
 * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
 */
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.sun.org.apache.bcel.internal.classfile;

import com.sun.org.apache.bcel.internal.Const;
import java.io.DataInput;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

Extends the abstract Constant to represent a reference to a UTF-8 encoded string. 
See Also:
Constant
@LastModified
: Jan 2020/**
 * Extends the abstract {@link Constant} to represent a reference to a UTF-8 encoded string.
 *
 * @see Constant
 * @LastModified: Jan 2020
 */
public final class ConstantUtf8 extends Constant {

    private static class Cache {

        private static final boolean BCEL_STATISTICS = false;
        private static final int MAX_ENTRIES = 20000;
        private static final int INITIAL_CAPACITY = (int) (MAX_ENTRIES / 0.75);

        private static final HashMap<String, ConstantUtf8> CACHE = new LinkedHashMap<String, ConstantUtf8>(
            INITIAL_CAPACITY, 0.75f, true) {

            private static final long serialVersionUID = -8506975356158971766L;

            @Override
            protected boolean removeEldestEntry(final Map.Entry<String, ConstantUtf8> eldest) {
                return size() > MAX_ENTRIES;
            }
        };

        // Set the size to 0 or below to skip caching entirely
        private static final int MAX_ENTRY_SIZE = 200;

        static boolean isEnabled() {
            return Cache.MAX_ENTRIES > 0 && MAX_ENTRY_SIZE > 0;
        }

    }

    
Clears the cache.
Since:
6.4.0/**
     * Clears the cache.
     *
     * @since 6.4.0
     */
    public static synchronized void clearCache() {
        Cache.CACHE.clear();
    }

    
Gets a new or cached instance of the given value.
 See ConstantUtf8 class Javadoc for details. 
Params:
value – the value.
Returns:
a new or cached instance of the given value.
Since:
6.0/**
     * Gets a new or cached instance of the given value.
     * <p>
     * See {@link ConstantUtf8} class Javadoc for details.
     * </p>
     *
     * @param value the value.
     * @return a new or cached instance of the given value.
     * @since 6.0
     */
    public static ConstantUtf8 getCachedInstance(final String value) {
        if (value.length() > Cache.MAX_ENTRY_SIZE) {
            return new ConstantUtf8(value);
        }

        synchronized (ConstantUtf8.class) { // might be better with a specific lock object
            ConstantUtf8 result = Cache.CACHE.get(value);
            if (result != null) {
                return result;
            }
            result = new ConstantUtf8(value);
            Cache.CACHE.put(value, result);
            return result;
        }
    }

    
Gets a new or cached instance of the given value.
 See ConstantUtf8 class Javadoc for details. 
Params:
dataInput – the value.
Throws:
IOException – if an I/O error occurs.
Returns:
a new or cached instance of the given value.
Since:
6.0/**
     * Gets a new or cached instance of the given value.
     * <p>
     * See {@link ConstantUtf8} class Javadoc for details.
     * </p>
     *
     * @param dataInput the value.
     * @return a new or cached instance of the given value.
     * @throws IOException if an I/O error occurs.
     * @since 6.0
     */
    public static ConstantUtf8 getInstance(final DataInput dataInput) throws IOException {
        return getInstance(dataInput.readUTF());
    }

    
Gets a new or cached instance of the given value.
 See ConstantUtf8 class Javadoc for details. 
Params:
value – the value.
Returns:
a new or cached instance of the given value.
Since:
6.0/**
     * Gets a new or cached instance of the given value.
     * <p>
     * See {@link ConstantUtf8} class Javadoc for details.
     * </p>
     *
     * @param value the value.
     * @return a new or cached instance of the given value.
     * @since 6.0
     */
    public static ConstantUtf8 getInstance(final String value) {
        return Cache.isEnabled() ? getCachedInstance(value) : new ConstantUtf8(value);
    }

    private final String value;

    
Initializes from another object.
Params:
constantUtf8 – the value./**
     * Initializes from another object.
     *
     * @param constantUtf8 the value.
     */
    public ConstantUtf8(final ConstantUtf8 constantUtf8) {
        this(constantUtf8.getBytes());
    }

    
Initializes instance from file data.
Params:
dataInput – Input stream
Throws:
IOException – /**
     * Initializes instance from file data.
     *
     * @param dataInput Input stream
     * @throws IOException
     */
    ConstantUtf8(final DataInput dataInput) throws IOException {
        super(Const.CONSTANT_Utf8);
        value = dataInput.readUTF();
    }

    
Params:
value – Data/**
     * @param value Data
     */
    public ConstantUtf8(final String value) {
        super(Const.CONSTANT_Utf8);
        if (value == null) {
            throw new IllegalArgumentException("Value must not be null.");
        }
        this.value = value;
    }

    
Called by objects that are traversing the nodes of the tree implicitely defined by the contents of a Java class.
I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.
Params:
v – Visitor object/**
     * Called by objects that are traversing the nodes of the tree implicitely defined by the contents of a Java class.
     * I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.
     *
     * @param v Visitor object
     */
    @Override
    public void accept(final Visitor v) {
        v.visitConstantUtf8(this);
    }

    
Dumps String in Utf8 format to file stream.
Params:
file – Output file stream
Throws:
IOException – /**
     * Dumps String in Utf8 format to file stream.
     *
     * @param file Output file stream
     * @throws IOException
     */
    @Override
    public void dump(final DataOutputStream file) throws IOException {
        file.writeByte(super.getTag());
        file.writeUTF(value);
    }

    
Returns:
Data converted to string./**
     * @return Data converted to string.
     */
    public String getBytes() {
        return value;
    }

    
Params:
bytes – the raw bytes of this UTF-8
Deprecated:
(since 6.0)/**
     * @param bytes the raw bytes of this UTF-8
     * @deprecated (since 6.0)
     */
    @java.lang.Deprecated
    public void setBytes(final String bytes) {
        throw new UnsupportedOperationException();
    }

    
Returns:
String representation/**
     * @return String representation
     */
    @Override
    public String toString() {
        return super.toString() + "(\"" + Utility.replace(value, "\n", "\\n") + "\")";
    }
}