CodeThatAint «

## Summary

Below are the List of Features available in Code

1. Reading payload from JSON File and using it as mocked Response
2. Object creation from JSON File
---

## Things Newly Implemented

1. JSON Payload files are found in src/test/resources/json-data
2. In the Code Converstion to Employee Object after reading Employee JSON and Stringify of JSON Object are both done  
3. MockMvc Testing is implemented for Controllers	
	- For AddEmployee Endpoint - Request from JSON file, Response from mocked response  
	- For GetEmployee Endpoint - Request by URL, Response from mocked Employee object constructed from JSON File
	- For GetAllEmployees Endpoint - Request by URL, Response from method returning Employee Object
	- For DeleteEmployee Endpoint - Request by URL, Response from mocked method	 	  
---

## Changes in pom.xml 
```xml
<build>
    <testResources>
        <testResource>
            <directory>${project.basedir}/src/test/resources</directory>
        </testResource>			
    </testResources>
    .
    .
    .
</build>
```
---

# API endpoints
## GET
`Get All Employees Detail` [/empmgmt/employees](#getallemployee) <br/>
`Get Employee Details` [/empmgmt/employees/{empId}](#getemployeesempid) <br/>

## POST
`Add Employee Details` [/empmgmt/employees](#addemployee) <br/>

## DELETE
`Delete EmpDetails` [/empmgmt/employees/{empId}](#deleteemployee) <br/>
___

<a name="getemployeesempid"></a>
### GET /empmgmt/employees/{empId}
Get Employee Detail

**Parameters**

|          Name | Required |  Type   | Description                                                                                                                                                           |
| -------------:|:--------:|:-------:| --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|     `empId` | required | string  | Employee Id

**Response**

```
// Employee Details added Succesfully
[
    {
        "empID": 1,
        "empName": "Mugil",
        "empAge": "36"
    }
]
```
___

<a name="getallemployee"></a>
### GET /empmgmt/employees

**Response**
```
// Employee Details added Succesfully
[
    {
        "empID": 1,
        "empName": "Mugil",
        "empAge": "36"
    }
]
```
___

<a name="addemployee"></a>
### POST /empmgmt/employees
Add Employee Details

**Parameters**

|          Name | Required |  Type   | Description                                                                                                                                                           |
| -------------:|:--------:|:-------:| --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|     `empName` | required | string  | Name of Employee
|     `empAge` | required | string  | Age of Employee

**Request**
```
// Employee Details 
{
    "empName" : "Mugil",
    "empAge" : "36"
}
```


**Response**

```
// Employee Details added Succesfully
[
    {
        "empID": 1,
        "empName": "Mugil",
        "empAge": "36"
    }
]
```
___

<a name="deleteemployee"></a>
### DELETE /empmgmt/employees/{empId}

**Parameters**

|          Name | Required |  Type   | Description                                                                                                                                                           |
| -------------:|:--------:|:-------:| --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|     `empId` | required | string  | Employee Id


**Response**

```
Employee Deleted Successfully
```
___



## Note

* While reading file from resources folder I continously got error telling the file doesnot exists. 
  The Same problem is faced while working in office project. After adding above lines in pom.xml it started 
  working. It kept working, even after removing above lines
* The URL returned in _Link in add employee wont have a port number. The test keeps failing if you copy and paste
  URL from postman and try to asset the _links in mockMVC

___

Copy paste the code in URL to see in action : https://markdownlivepreview.com/

Readme file screen shot for above code

TestTraits.java

package com.mugil.org;

import com.google.gson.Gson;
import com.mugil.org.models.Employee;
import org.springframework.core.io.ClassPathResource;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public interface TestTraits {
    public static Object getObjfromJson(String fileLoctaion) throws IOException {
        Gson gson = new Gson();
        Employee objEmployee2 = gson.fromJson(getReader(fileLoctaion), Employee.class);
        return objEmployee2;
    }

    public static Reader getReader(String fileLoctaion) throws IOException {
        return new FileReader(new ClassPathResource(fileLoctaion).getFile());
    }
}

EmployeeObject.json

{
  "empID": 101,
  "empName": "Mani",
  "empAge": "35"
}

EmployeeControllerTest.java
Read JSON Value as from File and Convert to Employee Object and to JSON String

JSON Value from File -> Employee Object -> JSON String from Object

  @Test
    void addEmployeeDetails() throws Exception {
        
        //Read values from JSON  
        Employee objEmployee = (Employee) TestTraits.getObjfromJson("json-data/EmployeeObject.json");

        //Convert Object to JSON String
        String jsonRequestString = mapper.writeValueAsString(objEmployee);

        when(employeeServiceImpl.saveEmployee(any())).thenReturn("101");

        ResultActions objResultActions = this.mockMvc.perform(post("/empmgmt/employees")
                .contentType(MediaType.APPLICATION_JSON)
                .content(jsonRequestString))
                .andDo(print())
                .andExpect(jsonPath("$.empID", is(Matchers.notNullValue())))
                .andExpect(jsonPath("$.empID", is(101)))
                .andExpect(jsonPath("$.empName", is("Mani")))
                .andExpect(status().isCreated());
    }

EmployeeControllerTest.java
Read JSON Value as from File and Convert to Employee Object and to JSON String

JSON Value from File -> Employee Object for Mocking Service Call


@Test
    void getEmployeeDetails() throws Exception {
          
        //Object Construction by reading file
        Employee objEmployee = (Employee) TestTraits.getObjfromJson("json-data/EmployeeObject.json");

        //Making object as Optional
        Optional<Employee> objEmp = Optional.ofNullable(objEmployee);

        //Mocked service response from object created
        when(employeeServiceImpl.findEmployee(EMP_ID)).thenReturn(objEmp);

        ResultActions objResultActions = this.mockMvc.perform(get("/empmgmt/employees/{empID}",EMP_ID))
                                                    .andDo(print())
                                                    .andExpect(jsonPath("$.empID", is(101)))
                                                    .andExpect(jsonPath("$.empName", is("Mani")))
                                                    .andExpect(jsonPath("$._links.all-employees.href", is("http://localhost/empmgmt/employees")))
                                                    .andExpect(status().isOk());
    }

Repo Link
https://bitbucket.org/Mugil/restwithspringboot/branch/feature/7MockMVCTesting_3

POST

 @Test
    void addEmployeeDetails() throws Exception {
        Employee objEmployee = (Employee) TestTraits.getObjfromJson("json-data/EmployeeObject.json");

        String jsonRequestString = mapper.writeValueAsString(objEmployee);

        when(employeeServiceImpl.saveEmployee(any())).thenReturn("101");

        ResultActions objResultActions = this.mockMvc.perform(post("/empmgmt/employees")
                .contentType(MediaType.APPLICATION_JSON)
                .content(jsonRequestString))
                .andDo(print())
                .andExpect(jsonPath("$.empID", is(Matchers.notNullValue())))
                .andExpect(jsonPath("$.empID", is(101)))
                .andExpect(jsonPath("$.empName", is("Mani")))
                .andExpect(status().isCreated());
    }

GET

 @Test
    void getEmployeeDetails() throws Exception {
        ClassLoader loader = Test.class.getClassLoader();
        Employee objEmployee = (Employee) TestTraits.getObjfromJson("json-data/EmployeeObject.json");

        Optional<Employee> objEmp = Optional.ofNullable(objEmployee);
        when(employeeServiceImpl.findEmployee(EMP_ID)).thenReturn(objEmp);

        ResultActions objResultActions = this.mockMvc.perform(get("/empmgmt/employees/{empID}",EMP_ID))
                                                    .andDo(print())
                                                    .andExpect(jsonPath("$.empID", is(101)))
                                                    .andExpect(jsonPath("$.empName", is("Mani")))
                                                    .andExpect(jsonPath("$._links.all-employees.href", is("http://localhost/empmgmt/employees")))
                                                    .andExpect(status().isOk());
    }

DELETE

 @Test
    void deleteEmployeeDetails() throws Exception {
        when(employeeServiceImpl.deleteEmployee(Long.valueOf(EMP_ID))).thenReturn(true);

        this.mockMvc.perform(delete("/empmgmt/employees/{empID}",EMP_ID))
                .andDo(print())
                .andExpect(content().string(containsString("Employee Deleted Successfully")))
                .andExpect(status().isOk());
    }

EmployeeControllerTest.java

package com.mugil.org.controllers;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.mugil.org.TestTraits;
import com.mugil.org.models.Employee;
import com.mugil.org.services.EmployeeServiceImpl;
import org.hamcrest.Matchers;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@ExtendWith(SpringExtension.class)
@WebMvcTest(EmployeeController.class)
class EmployeeControllerTest {

    @MockBean
    EmployeeServiceImpl employeeServiceImpl;

    ObjectMapper mapper = new ObjectMapper();

    @Autowired
    private MockMvc mockMvc;

    private static final String EMP_ID = "101";

    @Test
    void getEmployeeDetails() throws Exception {
        ClassLoader loader = Test.class.getClassLoader();
        Employee objEmployee = (Employee) TestTraits.getObjfromJson("json-data/EmployeeObject.json");

        Optional<Employee> objEmp = Optional.ofNullable(objEmployee);
        when(employeeServiceImpl.findEmployee(EMP_ID)).thenReturn(objEmp);

        ResultActions objResultActions = this.mockMvc.perform(get("/empmgmt/employees/{empID}",EMP_ID))
                                                    .andDo(print())
                                                    .andExpect(jsonPath("$.empID", is(101)))
                                                    .andExpect(jsonPath("$.empName", is("Mani")))
                                                    .andExpect(jsonPath("$._links.all-employees.href", is("http://localhost/empmgmt/employees")))
                                                    .andExpect(status().isOk());
    }

    @Test
    void deleteEmployeeDetails() throws Exception {
        when(employeeServiceImpl.deleteEmployee(Long.valueOf(EMP_ID))).thenReturn(true);

        this.mockMvc.perform(delete("/empmgmt/employees/{empID}",EMP_ID))
                .andDo(print())
                .andExpect(content().string(containsString("Employee Deleted Successfully")))
                .andExpect(status().isOk());
    }

    @Test
    void getAllEmployeeDetails() throws Exception {
        List<Employee> arrEmployees = new ArrayList<>();
        arrEmployees.add(getEmployee());

        when(employeeServiceImpl.findAllEmployee()).thenReturn(arrEmployees);

        ResultActions objResultActions = this.mockMvc.perform(get("/empmgmt/employees")
                .contentType(MediaType.APPLICATION_JSON))
                .andDo(print())
                .andExpect(jsonPath("$[0].empID", is(Matchers.notNullValue())))
                .andExpect(jsonPath("$[0].empID", is(101)))
                .andExpect(jsonPath("$[0].empName", is("Shivaji")))
                .andExpect(status().is2xxSuccessful());
    }

    @Test
    void addEmployeeDetails() throws Exception {
        Employee objEmployee = (Employee) TestTraits.getObjfromJson("json-data/EmployeeObject.json");

        String jsonRequestString = mapper.writeValueAsString(objEmployee);

        when(employeeServiceImpl.saveEmployee(any())).thenReturn("101");

        ResultActions objResultActions = this.mockMvc.perform(post("/empmgmt/employees")
                .contentType(MediaType.APPLICATION_JSON)
                .content(jsonRequestString))
                .andDo(print())
                .andExpect(jsonPath("$.empID", is(Matchers.notNullValue())))
                .andExpect(jsonPath("$.empID", is(101)))
                .andExpect(jsonPath("$.empName", is("Mani")))
                .andExpect(status().isCreated());
    }

    private Employee getEmployee(){
        Employee objEmployee = new Employee();

        objEmployee.setEmpID(Long.valueOf(101));
        objEmployee.setEmpAge("35");
        objEmployee.setEmpName("Shivaji");

        return objEmployee;
    }
}

Find the Minimum and Maximum Sum

Input Format
A single line of five space-separated integers.

Constraints

$1<arr[i]<10^9$

Output Format
Print two space-separated long integers denoting the respective minimum and maximum values.

Sample Input

1 2 3 4 5

Sample Output

10 14

Find the Minimum and Maximum Element in array
When you calculate the minSum and maxSum – discard the maxElement and minElement
Trick is you may miss logic if the array contains 5 elements and all are of same value. In such case the maximum and minimum value elements are same
For finding minimum number, start by assigning maximum number to minNum

.
.
 public static void miniMaxSum(List<Integer> arr) {
        long minNum = 0;
        long maxNum = 0;

        long minSum = 0;
        long maxSum = 0;


        //To find maximum Number
        for(int num=0;num<arr.size();num++){
            if(maxNum<=arr.get(num)){
                maxNum = arr.get(num);
            }
        }

        //To find minimum Number
        minNum = maxNum;

        for(int num=0;num<arr.size();num++){
            if(arr.get(num)<=minNum){
                minNum = arr.get(num);
            }
        }

        for(int num=0;num<arr.size();num++){
            //If the array elements are of same value
            if(num!=0 && arr.get(num) == arr.get(num-1)){
                minSum +=arr.get(num);
                maxSum +=arr.get(num);
            }


            if(arr.get(num) != maxNum)
              minSum +=arr.get(num);

            if(arr.get(num) != minNum)
              maxSum +=arr.get(num);
        }

        System.out.println(minSum);
        System.out.println(maxSum);
    }
.
.

Get Count of biggest Element in array – Total Tallest Candles to be blown

Input Format
Array of Integers

Constraints

$1<candles[i]<10^7$

Output Format
Count of Biggest Element in array

Sample Input

3 2 1 3 5 6 5 4 5

Sample Output

In the above example 6 is the biggest element and it occurs only once
Find the biggest element in array
Find the count of the biggest element

public static int birthdayCakeCandles(List<Integer> candles) {
        // Write your code here
        long tallestCandle = 0;
        int tallestCandleCnt = 0;

        for(int num=0;num<candles.size();num++){
            if(tallestCandle<=candles.get(num)){
                tallestCandle = candles.get(num);
            }
        }

        for(int num=0;num<candles.size();num++){
            if(candles.get(num) == tallestCandle)
                tallestCandleCnt +=1;
        }

        return tallestCandleCnt;
    }

கடவுள்(இறைவன்) இருக்கிறானா?

இருக்கிறான் என்று இறை-நம்பிக்கை உள்ளவர்களும், இல்லை என்று இறை-மறுப்பாளர்களும்,‘கடவுள் இருப்பதும், இல்லை என்பதும் கதைக்கு உதவாத வெறும் பேச்சு’ என்று உலகாதாயம் பேசுபவர்களும் மூன்று விதத்தில் விடை சொல்வார்கள்.

ஆனால், ‘உயிர்கள்’ உண்டா என்று யாரும் ஐயம் எழுப்புவது இல்லை!

உடல்களில் இயங்கும்போது, பல பெயர்கள் கொண்டு விளங்கும் உயிருடல்கள், உயிர் நீங்கினால், அனைத்து மனித உடல்களுக்கும் ‘பிணம்’ என்ற ஒரே பெயர்தான்.

ஐயா, ஐயா என்று வாஞ்சையாக அழைத்தவர்கள், உயிருடலில் இருந்து, ‘ஐயா’ என்ற உயிர் நீங்கிவிட்டால், ‘ஐயாவை எப்போது எடுப்பார்கள்?’ என்று யாரும் கேட்பதில்லை;
மாறாக, “பிணத்தை எப்போது எடுப்பார்கள்?” என்றுதான் கேள்வி வருவதை சாதாரணமாகக் காண்கிறோம்.

உயிர் நீங்கிய உடல் எரிக்கப்பட்டோ – புதைக்கப்பட்டோ சிதைவுறும்.

எனவே, உயிர் என்ற ஒன்றின் இருப்பை, எவரும் மறுப்பதில்லை. ஆயினும், உலகோர் அனைவரும், உடலை விட்டு நீங்கியதும்,

‘உயிர்’ என்னவாகிறது?
எங்கே போகிறது?
எப்படி உடலற்ற உயிரின் வாழ்வு அமையும்?

போன்ற வினாக்களை எழுப்பிக் கொண்டதால் வந்த விளைவுகள்தாம் கடவுள்கள் – மதங்கள் – சமயங்கள் – நம்பிக்கைகள் – சாமியார்கள் – பேய்கள் – செய்வினை – மந்திரங்கள் என்ற பலவும்.

உடல் வாழ்க்கைக்கு அப்புறம், உயிரின் நிலை என்ன என்ற கேள்வியின் விளைவே பல்வேறு சமயத் தத்துவங்கள்.

எனவே, உயிர்கள் என்றால் என்ன என்ற கேள்வி, மிகவும் பொருத்தமானதே! என்றாலும், உயிர்களுக்கும், இவ்வுலகத்துக்கும், இறைவன் என்னும் தத்துவப் பொருளுக்கும் உள்ள
தொடர்புக்கான விடை காண முயல்வதே, சமயங்கள் அல்லது மதங்கள் அனைத்துக்கும் இடையே இருக்கும் பொதுவான கூறு.

எனவே, உயிர் என்றால் என்ன? என்ற கேள்விக்கு,

இறைவன் என்றால் என்ன?
உயிர்-உலகம்-இறைவன் இவற்றிற்கான தொடர்பு என்ன?

இணைத்தே விடை காண முயலவேண்டும்.

இறைவன், உயிர்கள், உலகம் என்ற மூன்று பொருட்களையும், அவற்றிற்கு இடையேயான உறவுகளையும் அறுதியிட்டு, வரையறை செய்த சைவ சித்தாந்தம் என்னும் தத்துவத்தின் மூலம் உங்கள் கேள்விக்கு விடை தர முயற்சிக்கிறேன்.

இப்பிரபஞ்சத்தின் ‘முப்பெரும் உண்மைகள்’ என்று மூன்று பொருட்கள் சுட்டப்படுகின்றன.

‘முப்பெரும் உண்மைகள்’

இறைவன்(பதி)
உயிர்கள்(பசு)
தளைகள்(பாசம்)

எனப்படும்.

அகன்று எல்லையில்லாமல் விரிந்துகொண்டே செல்லும் (ever expanding universe) பரவெளியின் அனைத்தும் இம்மூன்று பொருட்களில் அடக்கம் என்கிறது சைவசித்தாந்தம் என்னும் சிவனியத்தத்துவம்.
உயிர்கள்(பசுக்கள்) இயல்பு!
உயிர்கள் அறிவுப்பொருட்கள்!

உயிர்கள் சார்ந்தவண்ணம் ஆதல் தன்மை கொண்டவை!(உயிரைப் பச்சோந்தி என்கிறீர்களா? ஆம், கிட்டத்தட்ட அப்படித்தான். உடலைச் சார்ந்து இருப்பதால், தான் என்பது உடலே என்று உணரும் உயிர்; உடலுக்கு நோய் வரும்போது, உயிர் அந்நோய் தனக்கே வந்தது என்று மயங்கும்.உடல்-மனம் மகிழ்வாக/சோகமாக இருக்கும்போது, உலகமே மகிழ்வாக /சோகமாக இருப்பதுபோல் எண்ணும்.அப்படியானால், உயிர் வேறு-உடல் வேறா? ஆம், என் கை, என் கால், என் உடலுக்கு முடியவில்லை என்று சொல்வதெல்லாம் என்னவாம்? உயிர் வேறு, உடல் வேறு என்பதால்தானே என் உடம்புக்கு முடியவில்லை என்கிறோம்!)

உயிர்கள் அறிவித்தால் மட்டுமே அறிபவை! (அப்படியா? சரியாகத்தான் படுகிறது. உயிர் அறிந்ததெல்லாம், கண்டும், கேட்டும், சுவைத்தும்,நுகர்ந்தும், தொட்டுஉணர்ந்தும் அறிந்தவை அல்லவா? அப்படியானால், எனது அறிவுக்கு, என் உடல்தான் மூலக்கருவியா? புரிந்தால் சரிதான். உடல் சார்ந்த மனம், புத்தி, சித்தம், அகங்காரம் என்றெல்லாம் இன்னும் சில உண்டு. பின்னர் குழம்பி, விளக்கித் தெளியலாம்.)

உயிர்கள் என்றும் உள்ளவை! (அப்படியானால், உயிர் போகிறது; சாவு வருகிறது எப்படி? பின்னர் விளக்குவோம்);

உயிர்கள் யாராலும் படைக்கப்படாதவை ! (கடவுள் படைக்காததா உயிர்கள்? தந்தை பெரியார் பேச்சை வைத்து காமெடி ஒன்றும் செய்யவில்லையே? உறுதியாக இல்லை. சைவசித்தாந்தத் தத்துவம் சொல்வதைத்தான் சொல்கிறேன்);

உயிர்கள் எண்ணற்றவை! (infinity – முடிவிலி என்று கணிதத்தில் சொல்வோமே, அதேதான். -∞ to +∞)
இதுவரை எத்தனை உயிர்கள் உடல்பிறவிகள் பிறந்து-இறந்துள்ளன? எண்ணற்றவை. (minus infinity: -∞)
இன்னும் எத்தனை உயிர்கள் பிறக்க இருக்கின்றன? எண்ணற்றவை. (plus infinity:+∞)
ஒரு உயிர் எத்தனை உடல் பிறவிகள் எடுக்கவேண்டும்? அந்தந்த உயிரின் வினைப்பயன்களைப் பொறுத்தது. (அப்ப, ஏழு பிறவி என்பதெல்லாம் பொய்யா? அது ஏழு பிறவி இல்லை. எழு பிறவி! அதாவது, வினைப்பயன்களுக்கு ஏற்றவாறு எழுகின்ற பல பிறவிகள். )
உயிர்கள், தன் இயல்பில், அறியாமை(ஆணவம்) என்னும் நுண்ணிய சடப்பொருளால் மறைக்கப்பட்டு, எங்கும் நிறையும் தன்மை இல்லாமல், கட்டுப்பட்டு மயங்கிக் கிடக்கும் குற்றம் உடையவை; அறிவித்தால் அறிபவை.

உயிர் எவ்வாறு இந்த உடல்-பிறவிக்கு வந்தது?
இறைவனால் என்கிறது சைவ சித்தாந்தம். இயற்கையால் என்கிறது அறிவியல்.

இனி, இறைவன் குறித்த கேள்விக்குச் செல்லலாம்.
இறைவன்(பதி) இயல்பு
இறைவன் (பதி) – ஒருவனே – என்றும் உள்ளவன் – தன் இயல்பில், யாரும் அறிவிக்காமல் அறியும் ஆற்றல் கொண்ட அறிவே வடிவானவன் – எல்லையற்ற ஆற்றல் கொண்டவன்.
கருணையே வடிவானவன் – வேண்டும்போது, வேண்டும் உருவம் கொள்ளும் ஆற்றல் கொண்டவன் – பொறிகள் புலன்கள் கொண்ட உடல்பிறவிக்கு வாராதவன் – எங்கும் நிறைந்தவன் –

தளைகள்(பாசம்) இயல்பு
தளைகள்(பாசம்) என்றும் உள்ள அறிவற்ற சடப்பொருளாகிய குற்றம் ஆகும்.
பாசம் என்ற தளை, ஆணவம், கன்மம், மாயை என்ற மூன்று வடிவங்களில் காணப்படும் – செம்புக்குக் களிம்பு போல் தன்னியல்பில், ஆணவம் உயிர்களைக் கட்டுவிக்கும் ஆற்றல் கொண்டவை.

உடலால் கட்டப்பட்ட உயிர், தன் உடலே தான் என்று கருதுவதை முன்னரே பார்த்தோம்.
இறைவன் அணுகினால், தளைகள்(பாசங்கள்) உயிர்களை விட்டு நீங்கும் இயல்பின.(ஆணவம், கன்மம், மாயை என்னும் மூவகைத் தளைகள் (பாசங்கள்-3) குறித்துப் பிற்பகுதியில் விரிவாக விளக்கியுள்ளேன்)

உயிர்கள் பால் இறைவனின் கருணை!

எல்லையற்ற கருணையாளன் இறைவன்,
• அறியாமையால் கட்டுண்ட உயிர்கள் மீது கொண்ட அன்பால், அவற்றைப் பிடித்த அறியாமை (ஆணவம்) நீங்க,
• உலகங்களைப் படைத்து, உலகங்களில் இயங்கும் உடல்களைப் படைத்து,
• அவ்வுடல்களில் உயிர்கள், தாமே இயங்கி, உடல்களில் பொருந்தியுள்ள பொறி-புலன்கள் வாயிலாக,
• புற உலகையும், பின்னர், தன்னை அறியும் அக-உலகையும் அறியும்படி
வாய்ப்புகள் வழங்குகிறான்.
திரோதான சக்தியும், அருட்சக்தியும்!
இப்படியான வாழ்க்கை முறையில், இறைவன் உயிர்களுடன் மறைந்து இருப்பது திரோதானம்(மறைப்புச்சக்தி) எனப்படும்.
தன்னை அறியும் உயிர்கள், தம் தலைவனாம் இறைவனை அறிதல் வேண்டித் தொழும்போது, இறைவன் வெளிப்பட்டுத் தோன்றி, உயிர்களின் இயல்பான முற்றறிவு என்னும் ஞானத்தை அருள்வான்; சீவன் என்னும் உயிர் சிவமாகும் வேளையில், அதற்கு, உடல் கருவி தேவை நீங்கும். சிவமாகும்.
அவ்வாறு,இறைவனால் அறியாமை நீங்கப் பெற்ற உயிர்கள், தம் தலைவன் இறைவனை அறிந்து, எங்கும் நிறையும் (வியாபகம்) சிவமாம் தன்மை பெற்று, சிவத்துடன் இரண்டறக் கலக்கும்.

இறைவன், உயிர்கள், உலகம்(இயற்கை-பேரண்டம் அனைத்தையும் உள்ளடக்கியது) என்ற மூன்று பொருட்களையும், அவற்றிற்கு இடையேயான உறவுகளையும் அறுதியிட்டு, வரையறை செய்த தத்துவமே சைவ சித்தாந்தம் எனப்படும்.

உலகம்-என்பது, மூன்று பொருட்களை ஒண்ணாக்கிச் சொன்னது என்பதை நினைவில் கொள்க!

பஞ்ச பூதங்கள்
முதலாவது செய்தி: உயிரற்ற சடப்பொருள் உலகம் என்பது, நிலம், நீர், தீ, காற்று, வெளி (வானம்) என்ற ஐந்து பொருட்களும் கொண்ட கலவை. ‘பஞ்ச பூதங்கள்’

ஐந்து அறியும் கருவிகள் – புலன்கள்

உயிர் என்ற அறிவுப்பொருளுக்கு, அறிவு கொடுக்கும் கருவியாக, இறைவனால் கொடுக்கப்பட்ட கருவி(Gadget)தான் நம் உடம்பு என்னும் உடல் – அதில், Five sensors-களும், Five senses-களும் உண்டு. (உடல்(மெய்) -touch sensor(தொட்டால் உணர்தல் கருவி, touch sense), வாய்-நாக்கு -taste sensor(சுவை உணரும் கருவி, taste sense), கண் – vision sensor(ஒளி பார்க்கும் பார்வைக் கருவி, vision sense), மூக்கு – sniffing sensor(மோப்பக் கருவி, sniffing sense), செவி – hearing sensor(ஒலி கேட்கும் கருவி, hearing sense)
நன்றாக சிந்தித்துப் பாருங்கள்! நமது அறிவு-என்பது இந்த ஐந்து அறியும் கருவிகள் – புலன்கள் இல்லாமல் நடக்குமா-என்று.

ஐந்து நுண்ணிய புலன்கள் (தன்மாத்திரைகள்)
இந்த ஐந்து அறியும் கருவிகளான மெய், வாய், கண், மூக்கு, செவி என்ற பொறிகளுக்கும், சுவை(த்தல்), ஒளி(பார்த்தல்), ஊறு(உணர்தல்), நாற்றம்(நுகர்தல்), ஓசை(கேட்டல்) என்னும் ஐந்து நுட்பமான புலன்கள் உண்டு.
ஐந்து தொழிற் கருவிகள் (கன்மேந்திரியங்கள்)
வாய் (பேச்சு/வாக்கு), கை(பாணி), கால்(பாதம்), எருவாய்(பாயு), கருவாய்(உபத்தம்) மனம் – புத்தி – சித்தம் -அகங்காரம்!

இந்த ஐந்து அறிகருவிகளையும், ஐந்து புலன்களையும் ஒருங்கிணைத்து செயலாற்றும் மனம் என்னும் கருவி, தகவல்களை மூளைக்கு அனுப்புகிறது.
மூளைக்குள் வந்த தகவல்கள் யாவை என்று ஏற்கனவே மூளையில் உள்ள தகவல்களுடன் ஒப்பிட்டு அறியும் கருவி ‘புத்தி’ எனப்படும். (இதுவும் வடமொழி சொல்லே!)
தீ எரிவதை, கண் என்ற பொறி கொண்டு பார்த்த மனம் தந்த தகவலை, ஏற்கனவே மூளையில் பதிந்துள்ள தகவலுடன் ஒப்பிட்டு, தீதான் என்று புத்தி சொல்லியதும்,

தீயை நீரைக் கொண்டு அணைக்கும் செயலைச் செய்யலாம் என்று பரிந்துரை செய்கிறது, சித்தம் என்னும் கருவி;
‘ஆம், நான் தீயை நீரைக் கொண்டு அணைக்கப் போகிறேன் என்று ‘முடிவு செய்கிறது’ அகங்காரம் என்னும் கருவி;
‘நீர் இருக்கும் தொட்டியை நோக்கி ஓடு’ என்று காலுக்குக் கட்டளை இடுகிறது; ‘வாளியை எடுத்து, நீரை முகர்ந்து ஊற்று’ என்று கைகளுக்குக் கட்டளை இடுகின்றது.
‘சேகர், நீயும் இன்னொரு வாளியில் நீரை எடுத்து ஊற்று’ என்று வாய்க்குக் கட்டளை இடுகின்றது;
இப்படி, இரண்டு கைகள், இரண்டு கால்கள், ஒரு வாய், கழிவுகளை வெளியேற்றும் எருவாய், விந்து-நாதம் கருவாய் ஆகிய ஐந்தும் ஏவல் வேலை செய்யும் இயந்திரங்கள் என்பதால்,வேலை-இயந்திரங்கள் – தொழிற்கருவிகள் ஐந்து என்கிறோம். (வடமொழியில், கர்மேந்திரியங்கள் ஐந்து)

இவ்றோடு மனம், புத்தி, சித்தம், அகங்காரம் (அந்தகரணங்கள்)என்னும் நான்கு தத்துவங்கள்.

சைவசித்தாந்தம் சொல்லும் 36 தத்துவங்கள்!

ஐந்து பருப்பொருட்கள்(பூதங்கள்), ஐந்து அறி-கருவிகள், ஐந்து அறி-புலன்கள், ஐந்து தொழிற்கருவிகள், நான்கு அந்தகரணங்கள் என்னும் இந்த இருபத்துநான்கு தத்துவங்களோடு வித்தியா தத்துவங்கள் 7, சிவதத்துவங்கள் 5 கூட்டி வரும் 12 தத்துவங்களையும் (பின்னர் விளக்குகிறேன்; இப்போதைக்கு, பதி,பசு,பாசம் அறிவோம்) சேர்த்து 36 தத்துவங்கள் என்பது சைவ சமய, சைவ சித்தாந்தத்தின் முடிபு ஆகும். (நாம் அறிந்து கொண்ட முடிபு – கொண்முடிபு)

ஆணவம், கன்மம், மாயை என்ற மூன்று வகைப் பாசங்கள்-பாசம்!

உயிர்களை இயல்பாகப் பற்றியுள்ள அறியாமை (ஆணவம்),
உயிர்களின் அறியாமையை(ஆணவத்தை) அகற்ற இறைவன் தந்த அறிவுக் கருவிகளான 24 தத்துவங்கள் வழியாக உயிர்கள் வினைகள் செய்து செயலாற்றுவதால், விளையும் வினைப் பயன்கள் (கன்மம்/கருமம்),
அறியாமை நீக்கவே, இறைவன் மாயை வழியாக, உலகம் என்னும் University-யில், உடல்-என்னும் Hostel-லில், வாழ்க்கை என்னும் 100 ஆண்டு Course படிக்க அனுப்புகிறான்.
வந்த வேலையை விட்டுவிட்டு, உழைப்பதெல்லாம் உணவின் பொருட்டே-என்று உழல்கிறோம்!
University-ல சேர்ந்தோமா, hostel-லுக்குப் போனோமா, படிச்சு முடிச்சு, Degree என்ற ஞானத்தைப் பெற்று, இறைவனுடன் இரண்டறக் கலத்தல் என்னும் நிலையான வேலைக்கு முயற்சி செய்யாமல்,
- Hostel சாப்பாட்டையே ருசிச்சுச் சாப்பிட்டுவிட்டு,
- hostel என்னும் உடலிலேயே வாழ என்ன வழின்னு யோசிச்சு, வாழ்க்கையை வீணாக்கி, வினையை சம்பாதிச்சு,
- fail-ஆகி, கருமவினைகளைத் தீர்க்க மீண்டும், மீண்டும் University என்னும் உலகத்துக்கு வந்து,
- Hostel-என்னும் உடலில் மீண்டும் நுழைந்து, மீண்டும் fail ஆகி, சுத்திக்கிட்டே இருக்கோம்.

நாம இந்த உலகத்துக்கு வந்த வேலையைப் பார்க்காமல், அறியாமை என்னும் ஆணவத்தால், வினைகளை ஈட்டி, மீண்டும், மாயையால், பிறந்து, இறந்து உழல்கிறோம்.
இறைவனை அறியும்முழுமையான அறிவே முழு விடுதலை!

இந்த அறியாமை(ஆணவம்), வினைகள்(கன்மம்) காரணங்களாக,

மீண்டும் பாசம் என்னும் ஆணவம், கன்மம், மாயையில் சிக்காமல் விடுபட,
மனிதன் முயற்சி செய்து, இறைவனிடம் அடைக்கலம் புகவேண்டும்;

சக உயிர்களுக்கும், மனிதர்களுக்கும், கருணையும், தொண்டும் செய்வோருக்கு, இறைவன் அருள்கிறான்.
இறைவனுடன் கலத்தலே பாசத்திலிருந்து விடுதலை பெற வழி!
அறியாமை,(ஆணவம்), நல்வினை-தீவினைகள்(கன்மம்), மாயை ஆகிய பாசத்திலிருந்து உயிர்கள் விடுதலை பெற, இறைவனை அடைவது ஒன்றே ஒரே வழி என்பதைத் திருமந்திரம் அழகாக விளக்குகிறது.

பதி பசு பாசம் எனப் பகர் மூன்றில்
பதியினைப் போல், பசு பாசம் அநாதி!
பதியினைச் சென்று அணுகாப் பதிபாசம்
பதி அணுகில் பசுபாசம் நில்லாவே!
– திருமந்திரம்.

இறைவனைப்போல் உயிர்களும் ஆதி-அந்தம் இல்லாதவை!
இறைவன்(பதி), உயிர்கள்(பசு), தளைகள்(பாசம்) என்ற மூன்றையும் குறித்துச் சொல்வதானால், இறைவனைப் போலவே, உயிர்களும், தளைகளும், தொடக்கம், முடிவு இல்லாதவை!

உயிர்கள் இறைவனுக்குச் சமமா?

பாருங்கள்! இறைவனைப்போல், உயிருக்கும் தொடக்கம்-முடிவே இல்லை!
அப்படியானால், நமக்கும், இறைவனுக்கும் வித்தியாசம் இல்லை என்று கருதலாம் அல்லவா?
நாமும், இறைவனும் சமம்தானோ என்று தவறாகக் கருத வேண்டாம்!
இதைத்தானே வேதாந்தியும் சொல்லிக் குழப்பினார் என்று நினைக்க வேண்டாம்.

அடுத்த வரியில் அழகாக விளக்குகிறார் பாருங்கள்.
இறைவனை பாசங்கள் அணுகாது!

• ஆனால், பாசம் என்னும் தளைகள், இறைவனை (என்னும் பதியினைச் சென்று) அணுகக் கூட இயலாது.
• இறைவன் பாசங்கள் அணுக முடியாத தூய முழுமையான அறிவினைக் கொண்டவன்.
(முற்றுமான அறிவைக் கொண்டவன் என்ற பொருளில், முற்றறிவன் – வாலறிவன் என்று இறைவனைச் சொல்லுவோம். அவனுக்கு, ஐம்பொறி-புலன்கள் கொண்ட உடல் தேவையற்றவன்; அனைத்தையும் உடல் இல்லாமலேயே அறிபவன்; எங்கும் நிறைந்தவன்; உங்கள் உள்ளும், என்னுள்ளும் நிறைந்தவன்)
உயிர்களின் அறியாமை மலங்கள்(பாசம்) நீக்கவே உடல்-பிறவி!
எனவே, இயல்பாகவே,

அறியாமை(ஆணவம்) என்ற பாசம் பிடித்தே இருக்கும் உயிர்களின் அறியாமையைப் போக்கவே,
உடல்கள் கருவிகளைத் தந்து,
உலகம் என்னும் அறிவுக்கூடத்தில், உலவ விடுகிறான்;
டல்கள் மூலம் அறிவு பெற்று, உடல்களை விட்டு நீங்கும்போது, முற்றறிவன் இறைவனுடன் கலந்தால், உயிர்களுக்கும் உடல்-அறிவு தேவைகள் நீங்கிவிடும்;
பிறவிகள் நீங்கிவிடும்!

பிறவி-வினை-பிறவி சுழல் நீக்கும் இறைவன்!

பிறவிகள் வினைகளால் வருகின்றன.

பிறவிகளால், வினைகளை ஈட்டுகிறோம்.
முட்டையிலிருந்து கோழி, கோழியிலிருந்து முட்டை என்பதுபோல், வினையால் பிறவிகள், பிறவியால் வினைகள் என்ற சுழலை உடைக்கும் வல்லமை

இறைவனை அணுகினால் மட்டுமே கிடைக்கும் என்று அறிவோம்!
இறைவன்தான் நமக்குள்ளேயே இருக்கானே! அப்ப எப்படி மும்மலங்கள் என்னும் ஆணவம், கன்மம், மாயை நம்மைப் பிடித்தன?

இறைவன் எங்கும் இருப்பதுபோல், நம்முள்ளும் இருக்கிறான்;
நம்முள்ளே அவன் இருந்தாலும், அவனுள்ளே நாம் கலக்கவில்லையே?
அப்படி ஒருவன் நம்ப கூட இருக்கிறான்-னு நாம்தான் கண்டு கொள்வதே இல்லையே!
மனிதன் எப்பவாது நம்பளக் கண்டுக்குவான்; அப்பத்தான், மனிதனை நாம் ஆட்கொள்வோம் என்று இறைவன் காத்துக்கொண்டே இருக்கிறான்.

நம்முள் இருந்தாலும், தூய உடம்பினனான இறைவனை மலங்கள் பிடிக்காது.

ஆக, மும்மலங்கள்(ஆணவம், கன்மம், மாயை) என்னும் தளைகளை ஒழிக்க ஒரே வழி, இறைவனை நாம் நினைந்து அணுகினால் போதும்.
இறைவனின் சந்நிதானத்தில், உயிர்களைப்(பசு) பிடித்துள்ள பசு-பாசம் நில்லாமல் ஓடிப்போகும் என்கிறார் திருமூலர்.

உயிருக்கான விளக்கத்தை சரியாக விளக்கிவிட்டேனா என்று அன்பர்கள்தான் கூற வேண்டும்!

அறுகம்புல்லை உண்ணுகின்ற பசுமாட்டின் சாணத்தை எடுத்து உருண்டையாக்கி வெயிலில் காயவைக்க வேண்டும். பின் இதனை உமியினால் மூடி புடம் போட்டு எடுக்க வேண்டும். இப்போது இந்த உருண்டைகள் வெந்து நீறாகி இருக்கும். இதுவே உண்மையான திருநீறாகும்.
இது நல்ல அதிர்வுகளை மட்டும் உள்வாங்கும் திறன் கொண்டது. எம்மைச் சுற்றி அதிர்வுகள் இருக்கின்றன என்பது யாவரும் அறிந்ததே.

எம்மை அறியாமலே அதிர்வுகளின் மத்தியில்த் தான் நாம் வாழ்ந்து கொண்டிருக்கின்றோம். எமது உடலானது இவ் அதிர்வுகளை ஏற்றுக் கொள்ளுகின்றது. திருநீறானது நல்ல அதிர்வுகளை ஏற்றுக் கொள்ளும் தன்மை வாய்ந்தது. அந்தவகையில் உடலின் முக்கிய பாகங்களில் திருநீறு இட்டுக் கொள்ளும் வழக்கம் இந்துமதத்தவர்களிடம் காணப்படுகின்றது.

இதைவிட மனித உடலிலே நெற்றி முக்கிய பாகமாகக் கருதப்படுகின்றது. அந்த நெற்றியிலேயே வெப்பம் அதிகமாகவும் வெளியிடப்படுகின்றது, உள் இழுக்வும்படுகின்றது. சூரியக்கதிர்களின் சக்தியை இழுத்து சரியான முறையில் உள்ளனுப்பும் அற்புதமான தொழிலை திருநீறு செய்யும் அதனாலேயே திருநீறை நெற்றியில் இடுவார்கள்.

தனது உடலிலே சாம்பல் சத்துக் குறைந்துவிட்டால், இலங்கை போன்ற வெப்பமான நாடுகளில் வளரும் கோழி இனங்கள் சாம்பலிலே விழுந்து குளிப்பதைக் கண்டிருப்பீர்கள். புறவை இனமே தன் தேவை தெரிந்து சாம்பலை நாடுகின்றதல்லவா! அதே போல்த்தான் மனிதனும் தன் மூட்டுவலி தோற்றுவிக்கும் இடங்களில் நீர்த்தன்மையை உறிஞ்சவல்ல திருநீற்றை அணிகின்றான். பசுமாட்டுச்சாணத்தை எரித்து திருநீறு செய்கின்றார்கள். மாடு அறுகம்புல் போன்ற பலவகையான புல்வகைகளை உண்டு தனது உடலைத் தேற்றிச் சாணம் போடும். அச்சாணம் தீயிலிடப்படும் போது ஏற்படும் இரசாயண மாற்றங்கள் உடலுக்கு மருத்துவத்தன்மையைக் கொடுக்கின்றது.

இதைவிட இரு புருவங்களுக்கும் இடையிலுள்ள பகுதியில் மிக நுண்ணிய நரம்பு அதிர்வலைகளை உள்ளன. அதனால் அந்த இடத்தைப் பயன்படுத்தி மனவசியம் இலகுவாகச் செய்யமுடியும். அதனாலேயே மனவசியத்தைத் தடுக்க அந்த இடத்தில் திருநீறு, சந்தனம் போன்றவை இடப்படுகின்றன. சந்தனம் நெற்றியில் வெளியிடப்படும் வெப்பத்தை நீக்குகின்றது. அதிகமான வெப்பம் கூடிய நாடுகளில் ஞாபகங்கள் முதலில் பதியப்படல், திட்டமிடல் போன்றவற்றிற்குத் தொழிற்படுகின்ற நெற்றிப்பகுதியிலுள்ள frontal cortex என்னும் இடத்தில் அணியப்படும் சந்தனமானது வெப்பம் மிகுதியால் ஏற்படும் மூளைச்சோர்வை நீக்குகின்றது.

சந்தனம் இரு புருவங்களுக்கும் இடையில் இடுகின்ற போது, முளையின் பின்பகுதியில் ஞாபகங்கள் பதிவுசெய்து வைத்திருக்கும் Hippocampus என்னும் இடத்திற்கு ஞாபகங்களை சிறப்பான முறையில் அனுப்புவதற்கு இந்த frontal cortex சிறப்பான முறையில் தொழிற்படும். உடலுக்குக் குளிர்ச்சியூட்டும் சந்தனத்தை நெற்றியிலும் உடலின் பல பாகங்களிலும் இந்து சமயத்தவர் அணிந்திருக்கும் காட்சி நகைச்சுவையாகப் பார்வைக்குத் தோன்றினாலும் அற்புதமான காரணமும் அதில் உண்டு பார்த்தீர்களா!

நெற்றியின் இரு புருவங்களுக்கும் இடையிலுள்ள நெற்றிப் பொட்டிலே பட்டும்படாமலும் சுண்டுவிரலை நேராகப்பிடித்தால் மனதில் ஒருவகை உணர்வு தோன்றும். அந்த உணர்வை அப்படியே வைத்துத் தியானம் செய்தால் மனஒருமைப்பாடு தோன்றும், சிந்தனை தெளிவுபெறும், எதையும் தெளிவாகப் புரிந்து கொள்ளும் நிலை தோன்றும். அந்த நெற்றிப் பொட்டு குளிர்ச்சியுடன் இருக்க வேண்டாமா? இதற்குச் சந்தனம் சரியான மருந்து.

இந்த உண்மைகளைச் சாதாரணமாகக் கூறி விளங்கவைக்க முடியாத மக்களுக்கு நிலையில்லா வாழ்வின் நிலையை உணர்த்தி திருநீற்றை உடலில் அணிய வைத்திருக்கின்றார்கள். மதத்தைக் காட்டி விஞ்ஞான விளக்கத்தை மறைத்துக் கூறிய விளக்கங்களினால் மதம் வென்றது விளக்கம் மறைந்தது.

விபூதி இட்டுக் கொள்ளும் இடங்களும், பலன்களும்
1. புருவ மத்தியில்(ஆக்ஞா சக்கரம்) வாழ்வின் ஞானத்தை ஈர்த்துக் கொள்ளலாம்.

2.தொண்டைக்குழி(விசுத்தி சக்கரம்) நமது சக்தியை அதிகரித்துக் கொள்ளலாம்.

3.நெஞ்சுக்கூட்டின் மையப்பகுதி தெய்வீக அன்பைப் பெறலாம். மேலும், பூதியை எடுக்கும் போது, மோதிரவிரலால் எடுப்பது மிகவும் சிறந்தது. ஏனென்றால், நம் உடலிலேயே மிகவும் பவித்ரமான பாகம் என்று அதைச் சொல்லலாம். நம் வாழ்வையே கட்டுப்படுத்தும் சூட்சுமம் அங்கு உள்ளது.

இதைப் படிக்க ஆரம்பிக்கும் முன் இது எல்லா “ஃபாஸ்ட்ஃபுட்” கோயில்களுக்கும் பொருந்தாது என்பதை கவனத்தில்கொள்ள வேண்டும். எல்லா லட்சணங்களையும் கொண்டிருக்கும் கோயில்களுக்கு மட்டும் தான் இது. பழங்காலத்துக் கோயில்களில் எல்லாம் இது 100% சதவிகிதம் உள்ளது.

எப்படி எனறு கேட்பவர்களுக்கு கொஞ்சம் விளக்கமாகச் சொல்கிறேன்.:

பூமியின் காந்த அலைகள் அதிகம் வீசப்படும் இடங்கள்தான் இந்தக் கோயில்களின் சரியான அமைவு. இது பொதுவாக ஊருக்கு ஒதுக்குப்புறமான இடங்கள், மலைகள் மற்றும் ஆழ்ந்த இடங்கள் தான் உகந்த இடங்கள்.

கோயில்களில் ஒரு அபரிதமான காந்த சக்தியும், பாஸிட்டிவ் எனர்ஜியும் அதிகம் கொண்டிருக்கும். இது நார்த் போல் சவுத் போல் திரஸ்ட் வகை ஆகும். முக்கிய சிலைதான் இந்த மையப்பகுதியில் வீற்றீருக்கும். அதை நாம் கர்ப்பகிரகம் அல்லது மூலஸ்தானம் என கூறுவோம்.

இந்த மூலஸ்தானம் இருக்கும் இடம் தான் அந்தச் சுற்று வட்டாரத்திலேயே காந்த மற்றும் பாஸிட்டிவ் எனர்ஜி அதிகம் காணப்படும். பொதுவாக இந்த மூலஸ்தானம் சுயம்பாக உருவாகும் அல்லது அங்கே கிடைக்கப் பெறும் சிலை அப்புறம் தான் கோயில் உருவாகும்.

நிறையக் கோயில்களின் கீழே அதுவும் இந்தக் கர்ப்பகிரகத்தின் கீழே சில செப்புத் தகடுகள் பதிக்கபட்டிருக்கும் அது எதற்கு தெரியுமா? அது தான் கீழே இருக்கும் அந்த சக்தியை அப்படி பன்மடங்காக்கி வெளிக் கொணரும்.

அதுபோக எல்லா மூலஸ்தானமும் மூன்று பக்கம் மூடி வாசல் மட்டும் தான் திறந்து இருக்கும் அளவுக்குக் கதவுகள் இருக்கும். இது அந்த சக்தியை விரயம் செய்யாமல் ஒரு வழியாக அதுவும் வாசலில் இடது மற்றும் வலது புறத்தில் இருந்து இறைவனை வணங்கும் ஆட்களுக்கு இந்தச் சக்தி கிடைக்கும்.

இது உடனே தெரியாமல் இருக்கும் ஒரு சக்தி வழக்கமாக கோயிலுக்குச் செல்லும் ஆட்களுக்குத் தெரியும் ஒருவித இனம்புரியாத சக்தி அந்தக் கோயிலில் கிடைக்கும் என்று.

அது போக கோயிலின் பிரகாரத்தை இடமிருந்து வலமாய் வரும் காரணம் சக்திச்சுற்றுப் பாதை இது தான். அதனால் தான் மூலஸ்தானத்தை சுற்றும் போது அப்படியே சக்திச் சுற்றுப்பாதை கூடச் சேர்ந்து அப்படியே உங்கள் உடம்பிலும் மனதிலும் சக்தி/ வலு வந்து சேரும். இந்தக் காந்த மற்றும் ஒருவித பாசிட்டிவ் மின்சார சக்தி நமது உடம்புக்கும் மனதிற்கும் ஏன் மூளைக்கும் தேவையான ஒரு பிரபஞ்ச சக்தி (பாஸிட்டிவ் காஸ்மிக் எனர்ஜி) ஆகும்.

மூலஸ்தானத்தில் ஒரு விளக்கு கண்டிப்பாய் தொடர்ந்து எரிந்து கொண்டிருக்கும். அது போக அந்த விக்கிரகத்திற்க்கு பின் ஒரு விளக்கு (இப்போது நிறைய கோயில்களில் பல்புதான்) அதைச் சுற்றிக் கண்ணாடி அது செயற்கை ஒளிவட்டம் வருவதற்க்கு அல்ல. அது அந்தச் சக்தியை அப்படித் திருப்பும் ஒரு உக்தியாகும்.

அது போக மந்திரம் சொல்லும் போதும், மணியடிக்கும் போதும் அங்கே செய்யபடும் அபிஷேகம் அந்த சக்தியை மென்மேலும் கூட்டி ஒரு கலவையாய் வரும் ஒரு அபரிதமான “எனர்ஜி ஃபேக்டரிதான்” மூலஸ்தானம்.

இவ்வளவு அபிஷேகம், கர்ப்பூர எரிப்பு, தொடர் விளக்கு எரிதல் இதை ஒரு அறையில் நீங்கள் செய்து பாருங்கள். இரண்டே நாளில் அந்த இடம் சாக்கடை நாற்றம் எடுக்கும். ஆனால் கோயிலில் உள்ள இந்தக் கர்ப்பக்கிரகம் மற்றும் எத்தனை வருடம் பால், தயிர், பஞ்சாமிர்தம், தேன், சந்தனம், குங்குமம், விபூதி மற்றும் எண்ணெய், சீயக்காய் போன்ற எவ்வளவு விஷயங்களை கொன்டு அபிஷேகம் செய்தாலும் இந்த இடம் நாற்றம் என்ற விஷயம் வரவே வராது.

அது போகக் கடைசியில் செய்யும் சொர்ணாபிஷேகம் இந்த சக்தியை ஒவ்வொரு நாளும் கூட்டிக்கொண்டே செல்லும். பூக்கள், கர்ப்பூரம் (பென்ஸாயின் கெமிக்கல்), துளசி (புனித பேஸில்), குங்குமப்பூ (சேஃப்ரான்),கிராம்பு (கிளவ்) இதை சேர்த்து அங்கு காப்பர் செம்பில் வைக்கபட்டு கொடுக்கும் தீர்த்தம் ஒரு அபரித சுவை மற்றும் அதன் சுவை கோயிலில் உள்ளது போல் எங்கும் கிடைக்காது.

இதை ஒரு சொட்டு அருந்தினால் கூட அதில் உள்ள மகிமை மிக அதிகம். இதை வழக்கமாக உட்கொண்டவர்களுக்கு இது ஒரு நோயெதிர்ப்பு “ஆன்டிபயாட்டிக்” என்றால் மிகையில்லை..

இதை மூன்று தடவை கொடுக்கும் காரணம் ஒன்று உங்கள் தலையில் தெளித்து இந்த உடம்பை புண்ணியமாக்க, மீதி இரண்டு சொட்டு உங்கள் உடம்பைப் பரிசுத்தமாக்குவதற்காகவேத் தரப்படுகின்றது..

இன்று ஆயிரம் பற்பசை அமெரிக்காவில் இருந்து வந்தாலும் ஏன் கிராம்பு, துளசி, வேம்பின் ஃபார்முலாவில் தயாரிக்கும் காரணம் இது தான் இந்த தீர்த்தம் வாய் நாற்றம், பல் சுத்தம் மற்றும் இரத்ததை சுத்தப்படுத்தும் ஒரு அபரிதமான கலவை தான் இந்தத் தீர்த்தம்.

கோயிலுக்கு முன்பெல்லாம் தினமும் சென்று வந்த இந்த மானிடர்களுக்கு எந்த வித நோயும் அண்டியது இல்லை என்பதற்கு இதுதான் காரணம்.

கோயிலின் அபிஷேகம் முடிந்து வஸ்த்திரம் சாத்தும் போது மற்றும் மஹா தீபாராதனை காட்டும் போது தான் கதவைத் திறக்கும் காரணம் அந்த சுயம்புக்கு செய்த அபிஷேக சக்தி எல்லாம் மொத்தமாக உருவெடுத்து அப்படியே அந்த ஜோதியுடன் ஒன்று சேர வரும்போது தான் கதவை அல்லது திரையைத் திறப்பார்கள். அது அப்படியே உங்களுக்கு வந்து சேரும். அது போக அந்த அபிஷேக நீரை எல்லோருக்கும் தெளிக்கும் போது உங்கள் உடம்பில் ஒரு சிலிர்ப்பு வரக் காரணமும் இது தான்.

கோயிலுக்கு மேல் சட்டை அணிந்து வர வேண்டாம் என கூறுவதற்கும் இது தான் முக்கிய காரணம். அந்த சக்தி அப்படியே மார்புக் கூட்டின் வழியே புகுந்து உங்கள் உடம்பில் சேர வேண்டும் என்பதனால்தான் நம் முன்னோர்கள் அவ்வாறு வகுத்தனர்.

பெண்களுக்கு தாலி அணியும் காரணமும் இது தான். நிறையப் பெண்களுக்கு ஆண்களை போன்று இதய நோய் வராமல் இருக்கும் காரணம் இந்த தங்க மெட்டல் இதயத்தின் வெளியே நல்ல “பாஸிட்டிவ் எனர்ஜியை” வாங்கி கொழுப்பைக் கூட கரைக்கும் சக்தி இருப்பதாக ஒரு கூடுதல் தகவல். மாங்கல்யம், கார் சாவி மற்றும் புது நகைகள் இதையெல்லாம் இங்கு வைத்து எடுத்தால் அந்த உலோகங்கள் இதன் சக்தியை அப்படியே பற்றிக் கொள்ளுமாம். இது சில பேனாக்கள் மற்றும் பத்திரிகை மற்றும் எல்லாவற்றுக்கும் பொருந்தும்.

கல்சிலையின் முன் வைத்து எடுப்பதனால் என்ன பலனென கேட்பவர்கள் தெரிந்து கொள்ளவேண்டியது என்னவென்றால், தொடர்ச்சியான வழிபாடுகளால் ஒருமுகப்படுத்தப்பட்ட பிரபஞ்ச சக்தியின் இருப்பிடமே அச்சிலை. அந்தச் சக்திதான் நாம் வழிபடும்போது அங்கிருந்து நம்மில் படும். பல மைல் தூரத்தில் இருந்து பயணம் செய்திருப்பினும் அந்த சில நொடிகளில் தரிசனம் கிட்டும்போது அந்த உடம்பில் ஒரு மென்மையான சிலிர்ப்பும், ஒரு வித நிம்மதியும் ஒரு சக்தி வந்து மிச்சம் உள்ள எவ்வளவு பெரிய பிரகாரத்தையும் சுற்றி வரும் ஒரு “எனர்ஜு ரீசார்ஜ் பாயின்ட் தான்” இந்தக் கோயிலின் மூலஸ்தானம்.

அது போக கோயிலின் கொடி மரத்திற்க்கும் இந்தப் பரிகாரத்திற்க்கும் ஒரு நேரடி “வயர்லெஸ்” தொடர்பு உண்டென்றால் அது மிகையாகாது.

கோயில் மேல் இருக்கும் கலசம் சில சமயம் இரிடியமாக மாற இது தான் காரணம். கீழ் இருந்து கிளம்பும் காந்த அலைகள் (மேக்னெட்டிக் வேவ்ஸ்) மற்றும் இடியின் தாக்கம் தான் ஒரு சாதாரண கலசத்தையும் இரிடியமாக மாற்றும் திறன் படைத்தது. கோயில்களில் இடி தாக்கும் அபாயம் இல்லாமல் போன காரணம் கோயில் கோபுரத்தில் உள்ள இந்தக் கலசங்கள் ஒரு சிறந்த மின்கடத்தி. ஆம்! இது தான் பிற்காலத்தில் கண்டெடுக்கப்பட்ட “லைட்னிங் அரெஸ்டர்ஸ்”.

அது போக கொடி மரம் இன்னொரு இடிதாங்கி மற்றும் இது தான் கோயிலின் வெளிப்பிரகாரத்தை காக்கும் இன்னொரு காப்பரண் (டெக்னிக்கல் புரட்டக்டர்). கோயில் கதவு என்றுமே மரத்தில் செய்யபட்டது ஏனென்றால் எல்லா “ஹை வோல்ட்டேஜெயும் நியூட்ர்ல்” செய்யும் ஆற்றல் இம்மரங்களுக்கு உண்டு..

இடி இறங்கினால் கோயிலின் கதவுகளில் உள்ள மணி கண்டிப்பாக அதிர்ந்து ஒருவித ஒலியை ஏற்படுத்தும் .நல்ல மானிடர் இருவேளை கோயிலுக்கு சென்று வந்தால் மனிதனின் உடல் மட்டுமல்ல அவனின் மனதும் மூளையும் சுத்தமாகும். இவ்வாறான கோயில் சுத்த சுவாதீனம் இல்லாதவர்களை கூட இந்தச் சக்தி ஒரு மாற்றத்தை அவர்களுள் ஏற்படுத்துவதனாலேயே கோயில்களில் இவர்கள் அமைதியாகின்றனர்.

கோயிலின் மடப்பள்ளியில் கிடைக்கும் புளியோதரை ஆகட்டும், சர்க்கரைப் பொங்கலாகட்டும் இந்த டேஸ்ட்டை எந்த ஒரு ஃபைவ் ஸ்டார் கிச்சனும் கொடுத்துவிட முடியாது என்பது தான் நியதி. சில கோயில்களில் இரண்டு அல்லது நாலு வாசல் இருக்கும் காரணம் இந்தச் சக்தி அப்படியே உங்களுடன் வெளியே செல்ல வேண்டும் எனற மூத்தோர்கள் நமக்கு வகுத்த சூத்திரம் தான் இந்தக் கோயில் “டெக்னாலஜி”

While Statement

Initialization
Condition
Task
Updation

.
.
int cnt = 1; //Initialization

while(cnt < 5) //Condition
{
 SOP("Hello"); //Task
 cnt++; //Updation
}

.
.

While loop becomes infinite loop if the updating has no effect on while loop condition

Print the numbers divisible by 4 till N
Approach 1

import java.util.Scanner;

public class displayWhile {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int count = scn.nextInt();
        int cnt = 4;

        while(cnt < count){
            if(cnt % 4 ==0)
             System.out.println(cnt);

            cnt++;
        }
    }
}

Approach 2

import java.util.Scanner;

public class displayWhile {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int count = scn.nextInt();
        int cnt = 4;

        while(cnt < count){
            System.out.println(cnt + " ");
            cnt+=4;
        }
    }
}

Input

Output

4 8 12 16 20 24 28 32 36

Approach2 is faster and efficient since count in while jumps in multiples of 4

Printing perfect Square

import java.util.Scanner;

public class PerfectSquare {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int n = scn.nextInt();
        int cnt = 1;

        while(cnt*cnt < n){
            System.out.println(cnt*cnt + " ");
            cnt++;
        }
    }
}

Input

Output

1 4 9 16 25

Printing last character in string

import java.util.Scanner;

public class PrintIntval {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        Character[] arrChar = new Character[]{};

        String strCount = String.valueOf(number);
        int index = strCount.length()-1;

        while(index >= 0 ) {
            System.out.println(strCount.charAt(index));
            index--;
        }
    }
}

Input

Output

Approach 2

import java.util.Scanner;

public class PrintIntval {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();

        while(number> 0 ) {
            System.out.println(number%10);
            number = number/10;
        }
    }
}

Input

Output

-----------------------------------------------------
 n           n>0           n%10         n=n/10   
----------------------------------------------------
1365          Y             5            136
136           Y             6            13
13            Y             3            1
1             Y             1            0
0             N - Loop Stops

Now how will you address if input is 0 por negative and you should get output?

To address above.. .

public class PrintIntval {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();

        if(number < 0)
            number *= -1;

        if(number == 0){
            System.out.println(number);
        }else {
            while (number > 0) {
                System.out.println(number % 10);
                number = number / 10;
            }
        }
    }
}

Input

-1365

Output

For Loop Syntax

for(Initialization; Condition; Updation)
{
  Loop Work
}

Print Odd numbers in For loop

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        int count = 1;
        
        for(int i=1;i<number;i=i+2){
          System.out.print(i + " ");                          
        }
        
    }
}

Input

Output

1 3 5 7 9

Factors
An Integer X is a factor of N if X divides N with no reminder

2 is factor of 4
4 is factor of 24

Factors of 10 are 1,2,5,10 leaving reminder 0
Factors of 24 are 1,2,3,4,6,8,12,24 leaving reminder 0

Minimum factor is the least factor which would be always 1
Maximum factor would be always N

All Factors lie between [1 to N]

Print Factors of a number

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        int count = 1;
        
        for(int i=1;i<=number;i++){
          if(number%i == 0){
             System.out.println(i);   
          }
        }
        
    }
}

Input

Output

1 2 3 4 6 8 12 24

Check the number is prime number

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        int factors = 0;
        
        for(int i=1;i<=number;i++){
          if(number%i == 0){
             factors++;   
          }
        }

     if(factors == 2){
       System.out.println("Prime No");
     }
        
    }
}

Input

Output

Prime No

Now in the above code I am checking the factors is equals to 2 and deciding whether the input is
prime no or not

Imagine you are giving 12 as input for above code

Input :- 12


         i               factor
	 1                  1
	 2                  2
	 3                  3-----> You can break here as we already know factor is greater than 2
	 4                  4
	 5                  4
	 6                  5
	 7                  5
	 8                  5
	 9                  5
	 10                 5
	 11                 5
	 12                 6

Refactoring the above for loop by adding break conditon

.
.
 for(int i=1;i<=number;i++){
     if(number%i == 0){
         factors++;   
      }
  }

  if(factors > 2){ //Break Factor 
     break;
  }
.
.

Using break factor in for loop

public class CheckPrimen {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        int factors = 0;

        for (int i = 1; i <= number; i++) {
            if (number % i == 0) {
                factors++;
            }

            if(factors > 2){ //Break Factor 
                break;
            }
        }

        if(factors == 2){
            System.out.println("Prime No");
        }else{
            System.out.println("Not a Prime No");
        }
    }
}

Input

Output

Print Odd numbers in For loop

Input

Output

forEach method in java.lang.Iterable interface
Java 8 has introduced forEach method in java.lang.Iterable interface so that while writing code we focus on business logic. The forEach method takes java.util.function.Consumer object as an argument, so it helps in having our business logic at a separate location that we can reuse.

myList.forEach(new Consumer < Integer > () {
    public void accept(Integer t) {
        System.out.println("forEach anonymous class Value::" + t);
    }

});

//traversing with Consumer interface implementation
MyConsumer action = new MyConsumer();
myList.forEach(action);

Consumer implementation that can be reused

class MyConsumer implements Consumer<Integer>{

	public void accept(Integer t) {
		System.out.println("Consumer impl Value::"+t);
	}
}

Interfaces with default and static methods
From Java 8, interfaces are enhanced to have a method with implementation. We can use default and static keyword to create interfaces with method implementation

We know that Java doesn’t provide multiple inheritance in Classes because it leads to Diamond Problem. So how it will be handled with interfaces now since interfaces are now similar to abstract classes. Compiler will throw an exception in this scenario and we will have to provide implementation logic in the class implementing the interfaces.

@FunctionalInterface
public interface Interface1 {

    void method1(String str);

    default void log(String str) {
        System.out.println("I1 logging::" + str);
    }

    static void print(String str) {
        System.out.println("Printing " + str);
    }
}

interfaces are not allowed to have Object default methods.

@FunctionalInterface annotation. Functional interfaces are a new concept introduced in Java 8. An interface with exactly one abstract method becomes a Functional Interface. We don’t need to use @FunctionalInterface annotation to mark an interface as a Functional Interface.
@FunctionalInterface annotation is a facility to avoid the accidental addition of abstract methods in the functional interfaces. You can think of it like @Override annotation and it’s best practice to use it. java.lang.Runnable with a single abstract method run() is a great example of a functional interface.

Anonymous Class Implementation
```
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("My Runnable");
    }
};
```
Lambda Expression Implementation
```
Runnable r1 = () - > {
    System.out.println("My Runnable");
};
```
If you have single statement in method implementation anonymous class can be instantiated using lambda expression as below
lambda expressions Implementation
```
Interface1 i1 = (s) -> System.out.println(s);		
i1.method1("abc");
```

New java.util.stream has been added in Java 8 to perform filter/map/reduce like operations with the collection. Stream API will allow sequential as well as parallel execution.

public static void main(String[] args) {

    List < Integer > myList = new ArrayList < > ();
    for (int i = 0; i < 100; i++) myList.add(i);

    //sequential stream
    Stream < Integer > sequentialStream = myList.stream();

    //parallel stream
    Stream < Integer > parallelStream = myList.parallelStream();

    //using lambda with Stream API, filter example
    Stream < Integer > highNums = parallelStream.filter(p - > p > 90);
    //using lambda in forEach
    highNums.forEach(p - > System.out.println("High Nums parallel=" + p));

    Stream < Integer > highNumsSeq = sequentialStream.filter(p - > p > 90);
    highNumsSeq.forEach(p - > System.out.println("High Nums sequential=" + p));

}

parallel processing values are not in order, so parallel processing will be very helpful while working with huge collections.

IO improvements known to me are:
Files.list(Path dir) that returns a lazily populated Stream, the elements of which are the entries in the directory.
Files.lines(Path path) that reads all lines from a file as a Stream.
Files.find() that returns a Stream that is lazily populated with Path by searching for files in a file tree rooted at a given starting file.
BufferedReader.lines() that return a Stream, the elements of which are lines read from this BufferedReader.
Java Time API packages, I can sense that they will be very easy to use. It has some sub-packages java.time.format that provides classes to print and parse dates and times and java.time.zone provides support for time zones and their rules.

M	T	W	T	F	S	S
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

M	T	W	T	F	S	S
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

CodeThatAint

Readme file example

Reading values from JSON File

Mock MVC Testing

Code Challenges 1

பசு-பாசம்-பதி

திருநீறு அணிவது ஏன்

கோயிலுக்கு நாம் ஏன் செல்ல வேண்டும்?

While Loop

For Loop

Java 8 New Features