rts-sim-module/repository/turnout.go

package repository

import (
	"errors"
	"fmt"
	"joylink.club/rtsssimulation/repository/model/proto"
)

type Turnout struct {
	Identity

	// 岔心的公里标
	km                *proto.Kilometer
	switchMachineType proto.Turnout_SwitchMachineType

	// 道岔关联的道岔物理区段
	section *PhysicalSection

	// A/B/C端口关联的设备端口（区段/道岔）
	aDevicePort DevicePort
	bDevicePort DevicePort
	cDevicePort DevicePort

	// A/B/C端口关联的Link端口
	aLinkPort *LinkPort
	bLinkPort *LinkPort
	cLinkPort *LinkPort

	// A/B/C端口的边界的公里标
	aKm *proto.Kilometer
	bKm *proto.Kilometer
	cKm *proto.Kilometer

	// A/B/C端口的边界在Link上的位置
	aLinkPosition *LinkPosition
	bLinkPosition *LinkPosition
	cLinkPosition *LinkPosition

	// A/B/C方向关联的设备（目前有信号机、应答器、(非区段边界)检测点）
	aDevices []Identity
	bDevices []Identity
	cDevices []Identity

	relayGroups []*RelayGroup
}

func NewTurnout(id string, km *proto.Kilometer, switchMachineType proto.Turnout_SwitchMachineType) *Turnout {
	return &Turnout{
		Identity:          identity{id, proto.DeviceType_DeviceType_Turnout},
		km:                km,
		switchMachineType: switchMachineType,
	}
}

func (t *Turnout) PortNum() int {
	return 3
}

func (t *Turnout) bindPhysicalSection(section *PhysicalSection) {
	t.section = section
}

func (t *Turnout) bindDevicePort(port proto.Port, devicePort DevicePort) error {
	_, isSectionPort := devicePort.(*PhysicalSectionPort)
	_, isTurnoutPort := devicePort.(*TurnoutPort)
	if !isSectionPort && !isTurnoutPort {
		return errors.New(fmt.Sprintf("道岔不能与[%s]类型的设备端口关联", devicePort.Device().Type()))
	}
	switch port {
	case proto.Port_A:
		t.aDevicePort = devicePort
	case proto.Port_B:
		t.bDevicePort = devicePort
	case proto.Port_C:
		t.cDevicePort = devicePort
	default:
		return errors.New(fmt.Sprintf("道岔无端口[%s]", port))
	}
	return nil
}

func (t *Turnout) bindLinkPort(port proto.Port, linkPort *LinkPort) {
	switch port {
	case proto.Port_A:
		t.aLinkPort = linkPort
	case proto.Port_B:
		t.bLinkPort = linkPort
	case proto.Port_C:
		t.cLinkPort = linkPort
	}
}

func (t *Turnout) bindBoundaryKm(km *proto.Kilometer, port proto.Port) error {
	switch port {
	case proto.Port_A:
		t.aKm = km
	case proto.Port_B:
		t.bKm = km
	case proto.Port_C:
		t.cKm = km
	default:
		return errors.New(fmt.Sprintf("道岔无端口[%s]", port))
	}
	return nil
}

func (t *Turnout) bindLinkPosition(port proto.Port, position *LinkPosition) {
	switch port {
	case proto.Port_A:
		t.aLinkPosition = position
	case proto.Port_B:
		t.bLinkPosition = position
	case proto.Port_C:
		t.cLinkPosition = position
	}
}

func (t *Turnout) bindDevice(device Identity, port proto.Port) {
	switch port {
	case proto.Port_A:
		t.aDevices = append(t.aDevices, device)
	case proto.Port_B:
		t.bDevices = append(t.bDevices, device)
	case proto.Port_C:
		t.cDevices = append(t.cDevices, device)
	}
}

func (t *Turnout) checkPoints() []*CheckPoint {
	var cps []*CheckPoint
	for _, device := range t.aDevices {
		cp, ok := device.(*CheckPoint)
		if ok {
			cps = append(cps, cp)
		}
	}
	for _, device := range t.bDevices {
		cp, ok := device.(*CheckPoint)
		if ok {
			cps = append(cps, cp)
		}
	}
	for _, device := range t.cDevices {
		cp, ok := device.(*CheckPoint)
		if ok {
			cps = append(cps, cp)
		}
	}
	return cps
}

// 获取指定端口连接的设备端口
func (t *Turnout) findDevicePortByPort(port proto.Port) DevicePort {
	switch port {
	case proto.Port_A:
		return t.aDevicePort
	case proto.Port_B:
		return t.bDevicePort
	case proto.Port_C:
		return t.cDevicePort
	default:
		return nil
	}
}

func (t *Turnout) findBoundaryKmByPort(port proto.Port) *proto.Kilometer {
	switch port {
	case proto.Port_A:
		return t.aKm
	case proto.Port_B:
		return t.bKm
	case proto.Port_C:
		return t.cKm
	}
	return nil
}

func (t *Turnout) findDevicesByPort(port proto.Port) []Identity {
	switch port {
	case proto.Port_A:
		return t.aDevices
	case proto.Port_B:
		return t.bDevices
	case proto.Port_C:
		return t.cDevices
	}
	return nil
}

func (t *Turnout) FindLinkPositionByPort(port proto.Port) *LinkPosition {
	switch port {
	case proto.Port_A:
		return t.aLinkPosition
	case proto.Port_B:
		return t.bLinkPosition
	case proto.Port_C:
		return t.cLinkPosition
	}
	return nil
}

func (t *Turnout) SwitchMachineType() proto.Turnout_SwitchMachineType {
	return t.switchMachineType
}

type TurnoutPort struct {
	turnout *Turnout
	port    proto.Port
}

func (t *TurnoutPort) Port() proto.Port {
	return t.port
}

func (t *TurnoutPort) Device() PortedDevice {
	return t.turnout
}

func (t *TurnoutPort) Turnout() *Turnout {
	return t.turnout
}