package memory_data_storage

type DataStorageInterface interface {
	GetLen() uint32
	Get(string) (string, bool)
	Set(string, string)
}

type dataStorage struct {
	data map[string]string
}

func NewDataStorage() DataStorageInterface {
	return &dataStorage{data: make(map[string]string)}
}

func (s *dataStorage) GetLen() uint32 {
	return uint32(len(s.data))
}

func (s *dataStorage) Get(key string) (string, bool) {
	if val, ok := s.data[key]; ok {
		return val, true
	}
	
  return "", false
}

func (s *dataStorage) Set(key string, value string) {
	s.data[key] = value
}

import (
	"math"
	"math/rand"
	"time"
)

// CalPi calculate pi
// it takes a long time, don't use it
func CalPi() float64 {
	rand.Seed(time.Now().UnixNano())
	iter := int(math.Pow(10, 8))
	n := 0
	for i := 0; i < iter; i++ {
		if math.Pow(rand.Float64(), 2)+math.Pow(rand.Float64(), 2) < 1 {
			n++
		}
	}
	return 4 * float64(n) / float64(iter)
}

// ShellSort performs the shell sort
func ShellSort(A []int, incr int) {
	for incr > 0 {
		for i := incr; i < len(A); i++ {
			j := i - incr
			for j >= 0 {
				if A[j] > A[j+incr] {
					A[j], A[j+incr] = A[j+incr], A[j]
					j -= incr
				} else {
					break
				}
			}
		}
		incr /= 2
	}
}

// ShellSort performs the shell sort
func ShellSort(A []int, incr int) {
	for incr > 0 {
		for i := incr; i < len(A); i++ {
			j := i - incr
			for j >= 0 {
				if A[j] > A[j+incr] {
					A[j], A[j+incr] = A[j+incr], A[j]
					j -= incr
				} else {
					break
				}
			}
		}
		incr /= 2
	}
}

// BinarySearch for value in sorted A
func BinarySearch(A []int, value int) int {
	low, high := 0, len(A)-1
	for low < high {
		mid := low + (high - low) >> 1
		if A[mid] > value {
			high = mid
		} else if A[mid] < value {
			low = mid + 1
		} else {
			return mid
		}
	}
	return -1
}

// BinarySearch for value in sorted A
func BinarySearch(A []int, value int) int {
	low, high := 0, len(A)-1
	for low < high {
		mid := low + (high - low) >> 1
		if A[mid] > value {
			high = mid
		} else if A[mid] < value {
			low = mid + 1
		} else {
			return mid
		}
	}
	return -1
}

// Search for value in A
func Search(A []int, value int) int {
	for i, a := range A {
		if value == a {
			return i
		}
	}
	return -1
}

package main

import (
	"path/filepath"

	"github.com/go-ole/go-ole"
	"github.com/go-ole/go-ole/oleutil"
)

func createShortcut(dst string, src string) error {
	ole.CoInitializeEx(0, ole.COINIT_APARTMENTTHREADED|ole.COINIT_SPEED_OVER_MEMORY)
	oleShellObject, err := oleutil.CreateObject("WScript.Shell")
	if err != nil {
		return err
	}
	defer oleShellObject.Release()
	wshell, err := oleShellObject.QueryInterface(ole.IID_IDispatch)
	if err != nil {
		return err
	}
	defer wshell.Release()
	cs, err := oleutil.CallMethod(wshell, "CreateShortcut", dst)
	if err != nil {
		return err
	}
	idispatch := cs.ToIDispatch()
	oleutil.PutProperty(idispatch, "TargetPath", src)
	oleutil.CallMethod(idispatch, "Save")
	return nil
}

func main() {
	dst := "test.lnk"
	src, _ := filepath.Abs("test.go")
	createShortcut(dst, src)
}

			const maxInt = int(^uint(0) >> 1)

type Majors struct {
	ID int    `json:"id" gorm:"type:serial;primary_key"`
	En string `json:"En"`
	Zh string `json:"Zh"`
	gormstruct.GormBase
}

func (this *Majors) TableName() string {
	return "toptutor.majors"
}