Getters

func (e *EncryptedIndex) GetIndexName() string

indexName := index.GetIndexName()
fmt.Printf("Working with index: %s\n", indexName)

func (e *EncryptedIndex) GetIndexType() string

indexType := index.GetIndexType()
fmt.Printf("Index type: %s\n", indexType)

// Use type for conditional logic
switch indexType {
case "ivf":
    fmt.Println("Using IVF (Inverted File) index")
case "ivfflat":
    fmt.Println("Using IVFFlat (IVF with flat search) index")
case "ivfpq":
    fmt.Println("Using IVFPQ (IVF with Product Quantization) index")
}

func (e *EncryptedIndex) IsTrained() bool

if index.IsTrained() {
    fmt.Println("Index is trained and optimized")
} else {
    fmt.Println("Index may benefit from training")
    // Optionally trigger training
    params := cyborgdb.TrainParams{}
    err := index.Train(context.Background(), params)
    if err != nil {
        log.Printf("Training failed: %v", err)
    }
}

func (e *EncryptedIndex) GetIndexConfig() internal.IndexConfig

config := index.GetIndexConfig()

// Access configuration based on index type
switch index.GetIndexType() {
case "ivf":
    if config.IndexIVFModel != nil {
        fmt.Printf("IVF Dimension: %d\n", config.IndexIVFModel.GetDimension())
    }
case "ivfflat":
    if config.IndexIVFFlatModel != nil {
        fmt.Printf("IVFFlat Dimension: %d\n", config.IndexIVFFlatModel.GetDimension())
    }
case "ivfpq":
    if config.IndexIVFPQModel != nil {
        fmt.Printf("IVFPQ Dimension: %d\n", config.IndexIVFPQModel.GetDimension())
        fmt.Printf("PQ Dimension: %d\n", config.IndexIVFPQModel.GetPqDim())
        fmt.Printf("PQ Bits: %d\n", config.IndexIVFPQModel.GetPqBits())
    }
}

func (e *EncryptedIndex) CheckTrainingStatus(ctx context.Context) (bool, error)

isTraining, err := index.CheckTrainingStatus(context.Background())
if err != nil {
    log.Printf("Failed to check training status: %v", err)
    return
}

if isTraining {
    fmt.Println("Index is currently being trained")
    // Wait for training to complete
    for isTraining {
        time.Sleep(10 * time.Second)
        isTraining, err = index.CheckTrainingStatus(context.Background())
        if err != nil {
            log.Printf("Error checking training status: %v", err)
            break
        }
        fmt.Println("Still training...")
    }
    fmt.Println("Training completed!")
} else if index.IsTrained() {
    fmt.Println("Index is trained")
} else {
    fmt.Println("Index is not trained and not currently training")
}