Rust Tutorial : Structures
from tutorialspoint.com

Declaring a structure
a structure is another user defined data type available in Rust
allows combining data items of different types, including another structure
a structure defines data as a key-value pair 
struct Name_of_structure {
   field1:data_type,
   field2:data_type,
   field3:data_type
}
Initializing a structure
after declaring a struct, each field should be assigned a value

example declares a struct Employee with three fields - name, company and age of types
the main() initializes the structure
uses the println! macro to print values of the fields defined in the structure 

struct Employee {
   name:String,
   company:String,
   age:u32
}
fn main() {
   let emp1 = Employee {
      company:String::from("TutorialsPoint"),
      name:String::from("Mohtashim"),
      age:50
   };
   println!("Name is :{} company is {} age is {}", emp1.name, emp1.company, emp1.age);
}
Modifying a struct instance
to modify an instance, the instance variable should be marked mutable
example declares and initializes a structure named Employee
later modifies value of the age field to 40 from 50 
let mut emp1 = Employee {
   company:String::from("TutorialsPoint"),
   name:String::from("Mohtashim"),
   age:50
};
emp1.age = 40;
println!("Name is :{} company is {} age is 
{}",emp1.name,emp1.company,emp1.age);
Passing a struct to a function
example shows how to pass instance of struct as a parameter
the display method takes an Employee instance as parameter and prints the details 
//declare a structure
struct Employee {
   name:String,
   company:String,
   age:u32
}
fn main() {
   //initialize a structure
   let emp1 = Employee {
      company:String::from("TutorialsPoint"),
      name:String::from("Mohtashim"),
      age:50
   };
   let emp2 = Employee{
      company:String::from("TutorialsPoint"),
      name:String::from("Kannan"),
      age:32
   };
   //pass emp1 and emp2 to display()
   display(emp1);
   display(emp2);
}
// fetch values of specific structure fields using the 
// operator and print it to the console
fn display( emp:Employee){
   println!("Name is :{} company is {} age is 
   {}", emp.name, emp.company, emp.age);
}
Returning a struct from a function
fn main() {
   //initialize structure
   let emp1 = Employee{
      company:String::from("TutorialsPoint"),
      name:String::from("Mohtashim"),
      age:50
   };
   let emp2 = Employee {
      company:String::from("TutorialsPoint"),
      name:String::from("Kannan"),
      age:32
   };
   let elder = who_is_elder(emp1,emp2);
   println!("elder is:");

   //prints details of the elder employee
   display(elder);
}
//accepts instances of employee structure and compares their age
fn who_is_elder (emp1:Employee,emp2:Employee)->Employee {
   if emp1.age>emp2.age {
      return emp1;
   } else {
      return emp2;
   }
}
//display name, comapny and age of the employee
fn display( emp:Employee) {
   println!("Name is :{} company is {} age is {}",emp.name,emp.company,emp.age);
}
//declare a structure
struct Employee {
   name:String,
   company:String,
   age:u32
}
Methods in a structure
methods are like functions
are a logical group of programming instructions
methods are declared with the fn keyword
the scope of a method is within the structure block

methods are declared outside the structure block
the impl keyword is used to define a method within the context of a structure
the first parameter of a method will be always self, which represents the calling instance of the structure
methods operate on the data members of a structure

To invoke a method, we need to first instantiate the structure
the method can be called using the structure's instance

syntax 

struct My_struct {}
impl My_struct { 
   //set the method's context
   fn method_name() { 
      //define a method
   }
}
example 
//define dimensions of a rectangle
struct Rectangle {
   width:u32, 
   height:u32
}

//logic to calculate area of a rectangle
impl Rectangle {
   fn area(&self)->u32 {
      //use the . operator to fetch the value of a field via the self keyword
      self.width * self.height
   }
}

fn main() {
   // instanatiate the structure
   let small = Rectangle {
      width:10,
      height:20
   };
   //print the rectangle's area
   println!("width is {} height is {} area of Rectangle 
   is {}",small.width,small.height,small.area());
}
Static methods in a structure
Static methods
static methods can be used as utility methods
these methods exist even before the structure is instantiated
static methods are invoked using the structure's name and can be accessed without an instance
a static method will not take the &self parameter

Declaring a static method
a static method like functions and other methods can optionally contain parameters 
impl Structure_Name {
   // static method that creates objects of the Point structure
   // no &self arg indicates static
   fn method_name(param1: datatype, param2: datatype) -> return_type {
      // logic goes here
   }
}
Invoking a static method
the structure_name :: syntax is used to access a static method 
//declare a structure
struct Point {
   x: i32,
   y: i32,
}
impl Point {
   // static method that creates objects of the Point structure
   // no &self arg indicates static
   fn getInstance(x: i32, y: i32) -> Point {
      Point { x: x, y: y }
   }
   // display values of the structure's field
   fn display(&self){
      println!("x ={} y={}",self.x,self.y );
   }
}
fn main(){
   // Invoke the static method
   let p1 = Point::getInstance(10,20);
   p1.display();
}
index