# Dictionary Implementation and Usage Guide
## Overview

This repository provides a simple dictionary implementation in Rust with various functions to manipulate 
and interact with the dictionary data structure. 
The dictionary allows you to store key-value pairs
where keys are of type String and values can be of any type T.

## Functions and Usage
### Include in project
```rs
use simple_dic::Dictionary;
```
### new(o:bool) -> Self
This function creates a new instance of the Dictionary struct.
The boolean paramater is a new and expiremental feature that adds the possibility to toggle of 
uniqueness. As it's not fully implemented, I suggest keeping it as true for now.
```rs
let mut my_dict = Dictionary::<T>::new(true);
```
### push(&mut self, key: String, value: T) -> Result<(), String>
Use this function to add a new key-value pair to the dictionary. 
If the key already exists, it returns an error message.
```rs
let key = "name".to_string();
let value = "John".to_string();

match my_dict.push(key, value) {
    Ok(()) => println!("Key-value pair added successfully."),
    Err(err) => println!("Error: {}", err),
}
```
### pop(&mut self)
This function removes the newest (last-added) key-value pair from the dictionary.
```rs
my_dict.pop();
```
### search(&self, key: String) -> bool
Use this function to check if a key exists in the dictionary.
```rs
if my_dict.search("name".to_string()) {
    println!("Key found!");
} else {
    println!("Key not found.");
}

```
### len(&self) -> usize
This function returns the number of key-value pairs in the dictionary.
```rs
let num_entries = my_dict.len();
println!("Number of entries in the dictionary: {}", num_entries);

```
### drop(&mut self, key: String) -> bool
This function deletes a key-value pair based on the provided key. It returns true if the key-value pair was found and deleted, otherwise false.
```rs
if my_dict.drop("name".to_string()) {
    println!("Key-value pair deleted successfully.");
} else {
    println!("Key-value pair not found.");
}

```
### contains(&self, value: &T) -> bool
This function checks if a given value exists in the dictionary's values.
```rs
if my_dict.contains(&"John".to_string()) {
    println!("Value found in the dictionary.");
} else {
    println!("Value not found.");
}

```
###index_of(&self,key: String) -> Result<Vec<usize>, String>
Searches and returns all indexes of a key
```rs
let key = "search_key";
    match obj.index_of(key.to_string()) {
    Ok(indices) => {
        println!("Indices of '{}': {:?}", key, indices);
    }
    Err(error) => {
        println!("Error: {}", error);
    }
}
```
### overwrite(&mut self, key: String, newvalue: T) -> Result<(), String>
This function overwrites the value associated with a key. If the key is found, the value is updated. If the key is not found, an error is returned. Not update for unique = false yet.
```rs
match my_dict.overwrite("name".to_string(), "Jane".to_string()) {
    Ok(()) => println!("Value updated successfully."),
    Err(err) => println!("Error: {}", err),
}

```
## Example
```rs
use simple_dic::Dictionary;

fn main() {
    let mut my_dict = Dictionary::new(true);
    
    my_dict.push("name".to_string(), "John".to_string()).unwrap();
    my_dict.push("age".to_string(), 25.to_string()).unwrap();

    println!("Dictionary contains 'name': {}", my_dict.search("name".to_string()));
    println!("Dictionary length: {}", my_dict.len());

    my_dict.pop();
    println!("Dictionary length after pop: {}", my_dict.len());

    my_dict.drop("age".to_string());
    println!("Dictionary length after drop: {}", my_dict.len());
}

```