zzz_notification.go

// Code generated by generate/main.go. DO NOT EDIT.
// source: api/api.proto

package iterm2

import (
	"fmt"
	"github.com/tjamet/goterm2/api"
)

type (
	KeystrokeNotifier func(*api.KeystrokeNotification) error

	ScreenUpdateNotifier func(*api.ScreenUpdateNotification) error

	PromptNotifier func(*api.PromptNotification) error

	LocationChangeNotifier func(*api.LocationChangeNotification) error

	CustomEscapeSequenceNotifier func(*api.CustomEscapeSequenceNotification) error

	NewSessionNotifier func(*api.NewSessionNotification) error

	TerminateSessionNotifier func(*api.TerminateSessionNotification) error

	LayoutChangedNotifier func(*api.LayoutChangedNotification) error

	FocusChangedNotifier func(*api.FocusChangedNotification) error

	ServerOriginatedRPCNotifier func(*api.ServerOriginatedRPCNotification) error

	BroadcastDomainsChangedNotifier func(*api.BroadcastDomainsChangedNotification) error

	VariableChangedNotifier func(*api.VariableChangedNotification) error

	ProfileChangedNotifier func(*api.ProfileChangedNotification) error
)

type Notifier struct {
	Keystroke []KeystrokeNotifier

	ScreenUpdate []ScreenUpdateNotifier

	Prompt []PromptNotifier

	LocationChange []LocationChangeNotifier

	CustomEscapeSequence []CustomEscapeSequenceNotifier

	NewSession []NewSessionNotifier

	TerminateSession []TerminateSessionNotifier

	LayoutChanged []LayoutChangedNotifier

	FocusChanged []FocusChangedNotifier

	ServerOriginatedRPC []ServerOriginatedRPCNotifier

	BroadcastDomainsChanged []BroadcastDomainsChangedNotifier

	VariableChanged []VariableChangedNotifier

	ProfileChanged []ProfileChangedNotifier
}

func (I *ITerm2) RegisterNotifier(notifier interface{}) error {

	if n, ok := notifier.(KeystrokeNotifier); ok {
		I.notifier.Keystroke = append(I.notifier.Keystroke, n)
		return nil
	}

	if n, ok := notifier.(ScreenUpdateNotifier); ok {
		I.notifier.ScreenUpdate = append(I.notifier.ScreenUpdate, n)
		return nil
	}

	if n, ok := notifier.(PromptNotifier); ok {
		I.notifier.Prompt = append(I.notifier.Prompt, n)
		return nil
	}

	if n, ok := notifier.(LocationChangeNotifier); ok {
		I.notifier.LocationChange = append(I.notifier.LocationChange, n)
		return nil
	}

	if n, ok := notifier.(CustomEscapeSequenceNotifier); ok {
		I.notifier.CustomEscapeSequence = append(I.notifier.CustomEscapeSequence, n)
		return nil
	}

	if n, ok := notifier.(NewSessionNotifier); ok {
		I.notifier.NewSession = append(I.notifier.NewSession, n)
		return nil
	}

	if n, ok := notifier.(TerminateSessionNotifier); ok {
		I.notifier.TerminateSession = append(I.notifier.TerminateSession, n)
		return nil
	}

	if n, ok := notifier.(LayoutChangedNotifier); ok {
		I.notifier.LayoutChanged = append(I.notifier.LayoutChanged, n)
		return nil
	}

	if n, ok := notifier.(FocusChangedNotifier); ok {
		I.notifier.FocusChanged = append(I.notifier.FocusChanged, n)
		return nil
	}

	if n, ok := notifier.(ServerOriginatedRPCNotifier); ok {
		I.notifier.ServerOriginatedRPC = append(I.notifier.ServerOriginatedRPC, n)
		return nil
	}

	if n, ok := notifier.(BroadcastDomainsChangedNotifier); ok {
		I.notifier.BroadcastDomainsChanged = append(I.notifier.BroadcastDomainsChanged, n)
		return nil
	}

	if n, ok := notifier.(VariableChangedNotifier); ok {
		I.notifier.VariableChanged = append(I.notifier.VariableChanged, n)
		return nil
	}

	if n, ok := notifier.(ProfileChangedNotifier); ok {
		I.notifier.ProfileChanged = append(I.notifier.ProfileChanged, n)
		return nil
	}

	return fmt.Errorf("notifier does not match any existing notifier")
}

func (I *ITerm2) dispatchNotification(n *api.Notification) {

	if n.GetKeystrokeNotification() != nil {
		for _, f := range I.notifier.Keystroke {
			go func(f KeystrokeNotifier, n *api.Notification) {
				err := f(n.GetKeystrokeNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about Keystroke: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetScreenUpdateNotification() != nil {
		for _, f := range I.notifier.ScreenUpdate {
			go func(f ScreenUpdateNotifier, n *api.Notification) {
				err := f(n.GetScreenUpdateNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about ScreenUpdate: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetPromptNotification() != nil {
		for _, f := range I.notifier.Prompt {
			go func(f PromptNotifier, n *api.Notification) {
				err := f(n.GetPromptNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about Prompt: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetLocationChangeNotification() != nil {
		for _, f := range I.notifier.LocationChange {
			go func(f LocationChangeNotifier, n *api.Notification) {
				err := f(n.GetLocationChangeNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about LocationChange: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetCustomEscapeSequenceNotification() != nil {
		for _, f := range I.notifier.CustomEscapeSequence {
			go func(f CustomEscapeSequenceNotifier, n *api.Notification) {
				err := f(n.GetCustomEscapeSequenceNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about CustomEscapeSequence: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetNewSessionNotification() != nil {
		for _, f := range I.notifier.NewSession {
			go func(f NewSessionNotifier, n *api.Notification) {
				err := f(n.GetNewSessionNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about NewSession: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetTerminateSessionNotification() != nil {
		for _, f := range I.notifier.TerminateSession {
			go func(f TerminateSessionNotifier, n *api.Notification) {
				err := f(n.GetTerminateSessionNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about TerminateSession: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetLayoutChangedNotification() != nil {
		for _, f := range I.notifier.LayoutChanged {
			go func(f LayoutChangedNotifier, n *api.Notification) {
				err := f(n.GetLayoutChangedNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about LayoutChanged: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetFocusChangedNotification() != nil {
		for _, f := range I.notifier.FocusChanged {
			go func(f FocusChangedNotifier, n *api.Notification) {
				err := f(n.GetFocusChangedNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about FocusChanged: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetServerOriginatedRpcNotification() != nil {
		for _, f := range I.notifier.ServerOriginatedRPC {
			go func(f ServerOriginatedRPCNotifier, n *api.Notification) {
				err := f(n.GetServerOriginatedRpcNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about ServerOriginatedRPC: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetBroadcastDomainsChanged() != nil {
		for _, f := range I.notifier.BroadcastDomainsChanged {
			go func(f BroadcastDomainsChangedNotifier, n *api.Notification) {
				err := f(n.GetBroadcastDomainsChanged())
				if err != nil {
					I.logger.Errorf("Failed to notify about BroadcastDomainsChanged: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetVariableChangedNotification() != nil {
		for _, f := range I.notifier.VariableChanged {
			go func(f VariableChangedNotifier, n *api.Notification) {
				err := f(n.GetVariableChangedNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about VariableChanged: %s", err)
				}
			}(f, n)
		}
	}

	if n.GetProfileChangedNotification() != nil {
		for _, f := range I.notifier.ProfileChanged {
			go func(f ProfileChangedNotifier, n *api.Notification) {
				err := f(n.GetProfileChangedNotification())
				if err != nil {
					I.logger.Errorf("Failed to notify about ProfileChanged: %s", err)
				}
			}(f, n)
		}
	}

}