private transient int size;
  private transient int mask;
  private transient int modCount;

  private HashBiMap(int expectedSize) {
    init(expectedSize);
  }

  private void init(int expectedSize) {
    checkNonnegative(expectedSize, "expectedSize");
    int tableSize = Hashing.closedTableSize(expectedSize, LOAD_FACTOR);
    this.hashTableKToV = createTable(tableSize);

	sys.Unlock()

	return meta, true, nil
}

// Init - initializes bucket metadata system for all buckets.
func (sys *BucketMetadataSys) Init(ctx context.Context, buckets []string, objAPI ObjectLayer) error {
	if objAPI == nil {
		return errServerNotInitialized
	}

	sys.objAPI = objAPI

	// Load bucket metadata sys.
	sys.init(ctx, buckets)
	return nil
}

    extraParameters: String = "",
    vcsRootId: String = gradlePromotionMaster
) : BasePublishGradleDistribution(promotedBranch, prepTask, triggerName, gitUserName, gitUserEmail, extraParameters, vcsRootId) {
    init {
        steps {
            if (prepTask != null) {
                buildStep(extraParameters, gitUserName, gitUserEmail, triggerName, prepTask, "uploadAll")

import (
	"net/http"

	"k8s.io/cli-runtime/pkg/resource"
	"k8s.io/client-go/rest/fake"
	cmdtesting "k8s.io/kubectl/pkg/cmd/testing"
	"k8s.io/kubectl/pkg/cmd/util"

	"istio.io/istio/pkg/kube"
)

func init() {
	MakeKubeFactory = func(k kube.CLIClient) util.Factory {
		tf := cmdtesting.NewTestFactory()
		_, _, codec := cmdtesting.NewExternalScheme()
		tf.UnstructuredClient = &fake.RESTClient{

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
)

var port int

func init() {
	flag.IntVar(&port, "port", 8080, "Port to listen on")
}

func mainHandler(w http.ResponseWriter, r *http.Request) {
	body, err := io.ReadAll(r.Body)
	defer r.Body.Close()
	if err != nil {

public class FessFileTransformer extends AbstractFessFileTransformer {
    private static final Logger logger = LogManager.getLogger(FessFileTransformer.class);

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }
        fessConfig = ComponentUtil.getFessConfig();
    }

    @Override

import jetbrains.buildServer.configs.kotlin.RelativeId
import vcsroots.gradlePromotionMaster

object StartReleaseCycle : BasePromotionBuildType(vcsRootId = gradlePromotionMaster) {
    init {
        id("Promotion_StartReleaseCycle")
        name = "Start Release Cycle"
        description = "Promotes a successful build on master as the start of a new release cycle on the release branch"

        params {

  }

  override fun source(): BufferedSource {
    return delegate.source()
  }

  override fun toString(): String {
    return javaClass.simpleName + "(" + delegate.toString() + ")"
  }

  init {
    requireNotNull(delegate) { "delegate == null" }
    this.delegate = delegate
  }

import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.CheckoutMode

abstract class BasePromotionBuildType(vcsRootId: String, cleanCheckout: Boolean = true) : BuildType() {
    init {
        vcs {
            root(AbsoluteId(vcsRootId))

            checkoutMode = CheckoutMode.ON_AGENT
            this.cleanCheckout = cleanCheckout
            showDependenciesChanges = true
        }

        <exclude>%regex[(?!((?!target/)[^/]+/)*src/).*target.*]</exclude>
        <exclude>**/*.log</exclude>
        <exclude>**/.gitignore</exclude>
        <exclude>**/.gitattributes</exclude>
        <exclude>init-git-svn.sh</exclude>
        <exclude>**/.repository/**</exclude>
        <exclude>**/.classpath</exclude>
        <exclude>**/.project</exclude>
        <exclude>**/.settings/**</exclude>
        <exclude>**/*.iml</exclude>