2_oo.go

package main
import (
        "fmt" ; "container/list" 
        "time"
        "errors"
)
type rect struct {
    width, height int
}
 
func (r *rect) area() int { //求面积
    return r.width * r.height
}
 
func (r *rect) perimeter() int{ //求周长
    return 2*(r.width + r.height)
}
 
func main1() {
    r := rect{width: 10, height: 15}
 
    fmt.Println("面积: ", r.area())
    fmt.Println("周长: ", r.perimeter())
 
    rp := &r
    fmt.Println("面积: ", rp.area())
    fmt.Println("周长: ", rp.perimeter())
    
    r2 := rect{width: 10, height: 10}
 
    fmt.Println("面积: ", r2.area())
    fmt.Println("周长: ", r2.perimeter())
    var x list.List
    x.PushBack(r)
    x.PushBack(r2)
    

    for e := x.Front(); e != nil; e=e.Next() {
        fmt.Println(e.Value.(rect))
    }
}
func main(){
//     main1()

        owner := Owner{name:"cat"}
        var rooms  list.List
        room := Room{id:1,name:"room1",beds:7}
        rooms.PushBack(room)
        room = Room{id:2,name:"room2",beds:8}
        rooms.PushBack(room)
        owner.rooms = rooms

    r1,_:=time.Parse("2006-01-02","2014-04-11")
    r2,_:=time.Parse("2006-01-02","2014-04-12")
    err := owner.do_reserve_room(1,r1,r2,5)
    if err!=nil{
            fmt.Println(err)
    }else{
        fmt.Println("reserved:",5)
    }
    err = owner.do_reserve_room(1,r1,r2,7)
    if err!=nil{
            fmt.Println(err)
    }else{
        fmt.Println("reserved:",5)
    }
    
    
}
func echo (reserves list.List){
        for e:=reserves.Front();e!=nil;e=e.Next(){
                res := e.Value.(Reserve)
                fmt.Println("ff:",res.room.name,res.beds,res.start,res.end)
        }
}
func (owner *Owner)do_reserve_room(room_id int,start time.Time,end time.Time,beds int)error{
        success,err := valid_date(start,end)
        if !success {
                fmt.Println("error:",err)//success
                return err
        }
        room,err := owner.find_room_by_id(room_id)
        if err != nil{
                return err
        }
        // fmt.Println("room.reserved_beds(start,end)",room.reserved_beds(start,end))
        last_beds := room.beds - owner.reserved_beds(room,start,end) 
        if last_beds < beds {        
              return errors.New(fmt.Sprintf("beds not enought ,have %d,needs %d",last_beds,beds))  
        }else{
                reserve := Reserve{room:room,beds:beds,start:start,end:end}
                owner.reserves.PushBack(reserve)
                return nil
        }
}
func datepart(t time.Time) (time.Time,error){
        s := t.Format("2006-01-02")
        return time.Parse("2006-01-02",s) 
}
func valid_date(start time.Time,end time.Time)(bool,error){
        if end.Before(start){
             return false, errors.New("end before start")  
        }
        now,_ := datepart(time.Now())
        if now.After(start){
                return false,errors.New("start eslaped")  
        }
        return true,nil
}
type Owner struct{
        name string
        rooms list.List
        reserves list.List
}
type Room struct{
        id int
        name string
        beds int
}
type Reserve struct{
        room Room
        beds int
        start time.Time
        end time.Time
}
func (r * Owner)find_room_by_id(id int)(Room,error){
        for e:=r.rooms.Front();e!=nil;e = e.Next(){
                if id == e.Value.(Room).id{return e.Value.(Room),nil}
        }
        return Room{},errors.New("not found")
}
func (r *Reserve)overlapped(req_start time.Time,req_end time.Time)bool{
        return !( req_start.After(r.start) || req_end.Before(r.start))
}
func (o *Owner)reserved_beds(r Room,start time.Time,end time.Time)int{
        answer := 0
        // fmt.Println("r.owner.reserves.Len()",r.owner.reserves.Len())
        if o.reserves.Len() ==0 {return 0}
        for e:= o.reserves.Front();e!=nil;e=e.Next(){
                reserve := e.Value.(Reserve) 
                fmt.Println("reserve.room.id",r.id,reserve.room.id)
                if reserve.room.id == r.id {
                        fmt.Println("overlapped",r.id,reserve.room.id,start,end)
                        if reserve.overlapped(start,end){
                                fmt.Println("overlapped",reserve.beds)
                                answer+=reserve.beds
                        }
                }
        }
        return answer
}