018c00e0-d6d2-44e5-aa77-74f47be0fdb8

Committed 24 Nov 2023 10:38AM UTC coverage: 64.703% (-0.05%) from 64.757%

Build # 018c00e0-d6d2-44e5-aa77-74f47be0fdb8

Build Type

push

buildkite

Run Details

13213 of 20421 relevant lines covered (64.7%)

316.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

21.2

/internal/compatibility/thrift/enum.go

// Copyright (c) 2021 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

package thrift

import (
        "go.uber.org/cadence/.gen/go/shared"

        apiv1 "github.com/uber/cadence-idl/go/proto/api/v1"
)

func TaskListKind(t apiv1.TaskListKind) *shared.TaskListKind {
        switch t {
        case apiv1.TaskListKind_TASK_LIST_KIND_INVALID:
                return nil
        case apiv1.TaskListKind_TASK_LIST_KIND_NORMAL:
                return shared.TaskListKindNormal.Ptr()
        case apiv1.TaskListKind_TASK_LIST_KIND_STICKY:
                return shared.TaskListKindSticky.Ptr()
        case apiv1.TaskListKind_TASK_LIST_KIND_EPHEMERAL:
                return shared.TaskListKindEphemeral.Ptr()
        }
        panic("unexpected enum value")
}

func TaskListType(t apiv1.TaskListType) *shared.TaskListType {
        if t == apiv1.TaskListType_TASK_LIST_TYPE_INVALID {
                return nil
        }
        switch t {
        case apiv1.TaskListType_TASK_LIST_TYPE_DECISION:
                return shared.TaskListTypeDecision.Ptr()
        case apiv1.TaskListType_TASK_LIST_TYPE_ACTIVITY:
                return shared.TaskListTypeActivity.Ptr()
        }
        panic("unexpected enum value")
}

func EventFilterType(t apiv1.EventFilterType) *shared.HistoryEventFilterType {
        if t == apiv1.EventFilterType_EVENT_FILTER_TYPE_INVALID {
                return nil
        }
        switch t {
        case apiv1.EventFilterType_EVENT_FILTER_TYPE_ALL_EVENT:
                return shared.HistoryEventFilterTypeAllEvent.Ptr()
        case apiv1.EventFilterType_EVENT_FILTER_TYPE_CLOSE_EVENT:
                return shared.HistoryEventFilterTypeCloseEvent.Ptr()
        }
        panic("unexpected enum value")
}

func QueryRejectCondition(t apiv1.QueryRejectCondition) *shared.QueryRejectCondition {
        if t == apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_INVALID {
                return nil
        }
        switch t {
        case apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_NOT_OPEN:
                return shared.QueryRejectConditionNotOpen.Ptr()
        case apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY:
                return shared.QueryRejectConditionNotCompletedCleanly.Ptr()
        }
        panic("unexpected enum value")
}

func QueryConsistencyLevel(t apiv1.QueryConsistencyLevel) *shared.QueryConsistencyLevel {
        if t == apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_INVALID {
                return nil
        }
        switch t {
        case apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_EVENTUAL:
                return shared.QueryConsistencyLevelEventual.Ptr()
        case apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_STRONG:
                return shared.QueryConsistencyLevelStrong.Ptr()
        }
        panic("unexpected enum value")
}

func ContinueAsNewInitiator(t apiv1.ContinueAsNewInitiator) *shared.ContinueAsNewInitiator {
        switch t {
        case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_INVALID:
                return nil
        case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_DECIDER:
                return shared.ContinueAsNewInitiatorDecider.Ptr()
        case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_RETRY_POLICY:
                return shared.ContinueAsNewInitiatorRetryPolicy.Ptr()
        case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_CRON_SCHEDULE:
                return shared.ContinueAsNewInitiatorCronSchedule.Ptr()
        }
        panic("unexpected enum value")
}

func WorkflowIDReusePolicy(t apiv1.WorkflowIdReusePolicy) *shared.WorkflowIdReusePolicy {
        switch t {
        case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_INVALID:
                return nil
        case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY:
                return shared.WorkflowIdReusePolicyAllowDuplicateFailedOnly.Ptr()
        case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE:
                return shared.WorkflowIdReusePolicyAllowDuplicate.Ptr()
        case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE:
                return shared.WorkflowIdReusePolicyRejectDuplicate.Ptr()
        case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING:
                return shared.WorkflowIdReusePolicyTerminateIfRunning.Ptr()
        }
        panic("unexpected enum value")
}

func QueryResultType(t apiv1.QueryResultType) *shared.QueryResultType {
        if t == apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID {
                return nil
        }
        switch t {
        case apiv1.QueryResultType_QUERY_RESULT_TYPE_ANSWERED:
                return shared.QueryResultTypeAnswered.Ptr()
        case apiv1.QueryResultType_QUERY_RESULT_TYPE_FAILED:
                return shared.QueryResultTypeFailed.Ptr()
        }
        panic("unexpected enum value")
}

func ArchivalStatus(t apiv1.ArchivalStatus) *shared.ArchivalStatus {
        switch t {
        case apiv1.ArchivalStatus_ARCHIVAL_STATUS_INVALID:
                return nil
        case apiv1.ArchivalStatus_ARCHIVAL_STATUS_DISABLED:
                return shared.ArchivalStatusDisabled.Ptr()
        case apiv1.ArchivalStatus_ARCHIVAL_STATUS_ENABLED:
                return shared.ArchivalStatusEnabled.Ptr()
        }
        panic("unexpected enum value")
}

func ParentClosePolicy(t apiv1.ParentClosePolicy) *shared.ParentClosePolicy {
        switch t {
        case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_INVALID:
                return nil
        case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_ABANDON:
                return shared.ParentClosePolicyAbandon.Ptr()
        case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_REQUEST_CANCEL:
                return shared.ParentClosePolicyRequestCancel.Ptr()
        case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_TERMINATE:
                return shared.ParentClosePolicyTerminate.Ptr()
        }
        panic("unexpected enum value")
}

func DecisionTaskFailedCause(t apiv1.DecisionTaskFailedCause) *shared.DecisionTaskFailedCause {
        switch t {
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_INVALID:
                return nil
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_UNHANDLED_DECISION:
                return shared.DecisionTaskFailedCauseUnhandledDecision.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SCHEDULE_ACTIVITY_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadScheduleActivityAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_REQUEST_CANCEL_ACTIVITY_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadRequestCancelActivityAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_START_TIMER_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadStartTimerAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_CANCEL_TIMER_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadCancelTimerAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_RECORD_MARKER_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadRecordMarkerAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_COMPLETE_WORKFLOW_EXECUTION_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadCompleteWorkflowExecutionAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_FAIL_WORKFLOW_EXECUTION_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadFailWorkflowExecutionAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_CANCEL_WORKFLOW_EXECUTION_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadCancelWorkflowExecutionAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadRequestCancelExternalWorkflowExecutionAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_CONTINUE_AS_NEW_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadContinueAsNewAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_START_TIMER_DUPLICATE_ID:
                return shared.DecisionTaskFailedCauseStartTimerDuplicateID.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_RESET_STICKY_TASK_LIST:
                return shared.DecisionTaskFailedCauseResetStickyTasklist.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_WORKFLOW_WORKER_UNHANDLED_FAILURE:
                return shared.DecisionTaskFailedCauseWorkflowWorkerUnhandledFailure.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SIGNAL_WORKFLOW_EXECUTION_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadSignalWorkflowExecutionAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_START_CHILD_EXECUTION_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadStartChildExecutionAttributes.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_FORCE_CLOSE_DECISION:
                return shared.DecisionTaskFailedCauseForceCloseDecision.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_FAILOVER_CLOSE_DECISION:
                return shared.DecisionTaskFailedCauseFailoverCloseDecision.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SIGNAL_INPUT_SIZE:
                return shared.DecisionTaskFailedCauseBadSignalInputSize.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_RESET_WORKFLOW:
                return shared.DecisionTaskFailedCauseResetWorkflow.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_BINARY:
                return shared.DecisionTaskFailedCauseBadBinary.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_SCHEDULE_ACTIVITY_DUPLICATE_ID:
                return shared.DecisionTaskFailedCauseScheduleActivityDuplicateID.Ptr()
        case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SEARCH_ATTRIBUTES:
                return shared.DecisionTaskFailedCauseBadSearchAttributes.Ptr()
        }
        panic("unexpected enum value")
}

func WorkflowExecutionCloseStatus(t apiv1.WorkflowExecutionCloseStatus) *shared.WorkflowExecutionCloseStatus {
        switch t {
        case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_INVALID:
                return nil
        case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_COMPLETED:
                return shared.WorkflowExecutionCloseStatusCompleted.Ptr()
        case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_FAILED:
                return shared.WorkflowExecutionCloseStatusFailed.Ptr()
        case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_CANCELED:
                return shared.WorkflowExecutionCloseStatusCanceled.Ptr()
        case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_TERMINATED:
                return shared.WorkflowExecutionCloseStatusTerminated.Ptr()
        case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_CONTINUED_AS_NEW:
                return shared.WorkflowExecutionCloseStatusContinuedAsNew.Ptr()
        case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_TIMED_OUT:
                return shared.WorkflowExecutionCloseStatusTimedOut.Ptr()
        }
        panic("unexpected enum value")
}

func QueryTaskCompletedType(t apiv1.QueryResultType) *shared.QueryTaskCompletedType {
        if t == apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID {
                return nil
        }
        switch t {
        case apiv1.QueryResultType_QUERY_RESULT_TYPE_ANSWERED:
                return shared.QueryTaskCompletedTypeCompleted.Ptr()
        case apiv1.QueryResultType_QUERY_RESULT_TYPE_FAILED:
                return shared.QueryTaskCompletedTypeFailed.Ptr()
        }
        panic("unexpected enum value")
}

func DomainStatus(t apiv1.DomainStatus) *shared.DomainStatus {
        switch t {
        case apiv1.DomainStatus_DOMAIN_STATUS_INVALID:
                return nil
        case apiv1.DomainStatus_DOMAIN_STATUS_REGISTERED:
                return shared.DomainStatusRegistered.Ptr()
        case apiv1.DomainStatus_DOMAIN_STATUS_DEPRECATED:
                return shared.DomainStatusDeprecated.Ptr()
        case apiv1.DomainStatus_DOMAIN_STATUS_DELETED:
                return shared.DomainStatusDeleted.Ptr()
        }
        panic("unexpected enum value")
}

func PendingActivityState(t apiv1.PendingActivityState) *shared.PendingActivityState {
        switch t {
        case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_INVALID:
                return nil
        case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_SCHEDULED:
                return shared.PendingActivityStateScheduled.Ptr()
        case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_STARTED:
                return shared.PendingActivityStateStarted.Ptr()
        case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_CANCEL_REQUESTED:
                return shared.PendingActivityStateCancelRequested.Ptr()
        }
        panic("unexpected enum value")
}

func PendingDecisionState(t apiv1.PendingDecisionState) *shared.PendingDecisionState {
        switch t {
        case apiv1.PendingDecisionState_PENDING_DECISION_STATE_INVALID:
                return nil
        case apiv1.PendingDecisionState_PENDING_DECISION_STATE_SCHEDULED:
                return shared.PendingDecisionStateScheduled.Ptr()
        case apiv1.PendingDecisionState_PENDING_DECISION_STATE_STARTED:
                return shared.PendingDecisionStateStarted.Ptr()
        }
        panic("unexpected enum value")
}

func IndexedValueType(t apiv1.IndexedValueType) shared.IndexedValueType {
        switch t {
        case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INVALID:
                panic("received IndexedValueType_INDEXED_VALUE_TYPE_INVALID")
        case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_STRING:
                return shared.IndexedValueTypeString
        case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_KEYWORD:
                return shared.IndexedValueTypeKeyword
        case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INT:
                return shared.IndexedValueTypeInt
        case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_DOUBLE:
                return shared.IndexedValueTypeDouble
        case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_BOOL:
                return shared.IndexedValueTypeBool
        case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_DATETIME:
                return shared.IndexedValueTypeDatetime
        }
        panic("unexpected enum value")
}

func EncodingType(t apiv1.EncodingType) *shared.EncodingType {
        switch t {
        case apiv1.EncodingType_ENCODING_TYPE_INVALID:
                return nil
        case apiv1.EncodingType_ENCODING_TYPE_THRIFTRW:
                return shared.EncodingTypeThriftRW.Ptr()
        case apiv1.EncodingType_ENCODING_TYPE_JSON:
                return shared.EncodingTypeJSON.Ptr()
        case apiv1.EncodingType_ENCODING_TYPE_PROTO3:
                panic("not supported yet")
        }
        panic("unexpected enum value")
}

func TimeoutType(t apiv1.TimeoutType) *shared.TimeoutType {
        switch t {
        case apiv1.TimeoutType_TIMEOUT_TYPE_INVALID:
                return nil
        case apiv1.TimeoutType_TIMEOUT_TYPE_START_TO_CLOSE:
                return shared.TimeoutTypeStartToClose.Ptr()
        case apiv1.TimeoutType_TIMEOUT_TYPE_SCHEDULE_TO_START:
                return shared.TimeoutTypeScheduleToStart.Ptr()
        case apiv1.TimeoutType_TIMEOUT_TYPE_SCHEDULE_TO_CLOSE:
                return shared.TimeoutTypeScheduleToClose.Ptr()
        case apiv1.TimeoutType_TIMEOUT_TYPE_HEARTBEAT:
                return shared.TimeoutTypeHeartbeat.Ptr()
        }
        panic("unexpected enum value")
}

func DecisionTaskTimedOutCause(t apiv1.DecisionTaskTimedOutCause) *shared.DecisionTaskTimedOutCause {
        switch t {
        case apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_INVALID:
                return nil
        case apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_TIMEOUT:
                return shared.DecisionTaskTimedOutCauseTimeout.Ptr()
        case apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_RESET:
                return shared.DecisionTaskTimedOutCauseReset.Ptr()
        }
        panic("unexpected enum value")
}

func CancelExternalWorkflowExecutionFailedCause(t apiv1.CancelExternalWorkflowExecutionFailedCause) *shared.CancelExternalWorkflowExecutionFailedCause {
        switch t {
        case apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID:
                return nil
        case apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION:
                return shared.CancelExternalWorkflowExecutionFailedCauseUnknownExternalWorkflowExecution.Ptr()
        case apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED:
                return shared.CancelExternalWorkflowExecutionFailedCauseWorkflowAlreadyCompleted.Ptr()
        }
        panic("unexpected enum value")
}

func SignalExternalWorkflowExecutionFailedCause(t apiv1.SignalExternalWorkflowExecutionFailedCause) *shared.SignalExternalWorkflowExecutionFailedCause {
        switch t {
        case apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID:
                return nil
        case apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION:
                return shared.SignalExternalWorkflowExecutionFailedCauseUnknownExternalWorkflowExecution.Ptr()
        case apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED:
                return shared.SignalExternalWorkflowExecutionFailedCauseWorkflowAlreadyCompleted.Ptr()
        }
        panic("unexpected enum value")
}

func ChildWorkflowExecutionFailedCause(t apiv1.ChildWorkflowExecutionFailedCause) *shared.ChildWorkflowExecutionFailedCause {
        switch t {
        case apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID:
                return nil
        case apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING:
                return shared.ChildWorkflowExecutionFailedCauseWorkflowAlreadyRunning.Ptr()
        }
        panic("unexpected enum value")
}

func CronOverlapPolicy(t apiv1.CronOverlapPolicy) *shared.CronOverlapPolicy {
        switch t {
        case apiv1.CronOverlapPolicy_CRON_OVERLAP_POLICY_INVALID:
                return nil
        case apiv1.CronOverlapPolicy_CRON_OVERLAP_POLICY_SKIPPED:
                return shared.CronOverlapPolicySkipped.Ptr()
        case apiv1.CronOverlapPolicy_CRON_OVERLAP_POLICY_BUFFER_ONE:
                return shared.CronOverlapPolicyBufferone.Ptr()
        }
        // we treat any unknown value as invalid
        return nil
}

func ActiveClusterSelectionStrategy(t apiv1.ActiveClusterSelectionStrategy) *shared.ActiveClusterSelectionStrategy {
        switch t {
        case apiv1.ActiveClusterSelectionStrategy_ACTIVE_CLUSTER_SELECTION_STRATEGY_INVALID:
                return nil
        case apiv1.ActiveClusterSelectionStrategy_ACTIVE_CLUSTER_SELECTION_STRATEGY_REGION_STICKY:
                return shared.ActiveClusterSelectionStrategyRegionSticky.Ptr()
        case apiv1.ActiveClusterSelectionStrategy_ACTIVE_CLUSTER_SELECTION_STRATEGY_EXTERNAL_ENTITY:
                return shared.ActiveClusterSelectionStrategyExternalEntity.Ptr()
        }
        // we treat any unknown value as invalid
        return nil
}

1	// Copyright (c) 2021 Uber Technologies, Inc.
2	//
3	// Permission is hereby granted, free of charge, to any person obtaining a copy
4	// of this software and associated documentation files (the "Software"), to deal
5	// in the Software without restriction, including without limitation the rights
6	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7	// copies of the Software, and to permit persons to whom the Software is
8	// furnished to do so, subject to the following conditions:
9	//
10	// The above copyright notice and this permission notice shall be included in
11	// all copies or substantial portions of the Software.
12	//
13	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19	// THE SOFTWARE.
20
21	package thrift
22
23	import (
24	"go.uber.org/cadence/.gen/go/shared"
25
26	apiv1 "github.com/uber/cadence-idl/go/proto/api/v1"
27	)
28
29	func TaskListKind(t apiv1.TaskListKind) *shared.TaskListKind {	344✔
30	switch t {	344✔
31	case apiv1.TaskListKind_TASK_LIST_KIND_INVALID:	235✔
32	return nil	235✔
33	case apiv1.TaskListKind_TASK_LIST_KIND_NORMAL:	109✔
34	return shared.TaskListKindNormal.Ptr()	109✔
35	case apiv1.TaskListKind_TASK_LIST_KIND_STICKY:	×
36	return shared.TaskListKindSticky.Ptr()	×
37	case apiv1.TaskListKind_TASK_LIST_KIND_EPHEMERAL:
38	return shared.TaskListKindEphemeral.Ptr()	×
39	}
40	panic("unexpected enum value")
41	}	×
42		×
43	func TaskListType(t apiv1.TaskListType) *shared.TaskListType {	×
44	if t == apiv1.TaskListType_TASK_LIST_TYPE_INVALID {	×
45	return nil	×
46	}	×
47	switch t {	×
48	case apiv1.TaskListType_TASK_LIST_TYPE_DECISION:	×
49	return shared.TaskListTypeDecision.Ptr()	×
50	case apiv1.TaskListType_TASK_LIST_TYPE_ACTIVITY:
51	return shared.TaskListTypeActivity.Ptr()	×
52	}
53	panic("unexpected enum value")
54	}	×
55		×
56	func EventFilterType(t apiv1.EventFilterType) *shared.HistoryEventFilterType {	×
57	if t == apiv1.EventFilterType_EVENT_FILTER_TYPE_INVALID {	×
58	return nil	×
59	}	×
60	switch t {	×
61	case apiv1.EventFilterType_EVENT_FILTER_TYPE_ALL_EVENT:	×
62	return shared.HistoryEventFilterTypeAllEvent.Ptr()	×
63	case apiv1.EventFilterType_EVENT_FILTER_TYPE_CLOSE_EVENT:
64	return shared.HistoryEventFilterTypeCloseEvent.Ptr()	×
65	}
66	panic("unexpected enum value")
67	}	×
68		×
69	func QueryRejectCondition(t apiv1.QueryRejectCondition) *shared.QueryRejectCondition {	×
70	if t == apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_INVALID {	×
71	return nil	×
72	}	×
73	switch t {	×
74	case apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_NOT_OPEN:	×
75	return shared.QueryRejectConditionNotOpen.Ptr()	×
76	case apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY:
77	return shared.QueryRejectConditionNotCompletedCleanly.Ptr()	×
78	}
79	panic("unexpected enum value")
80	}	×
81		×
82	func QueryConsistencyLevel(t apiv1.QueryConsistencyLevel) *shared.QueryConsistencyLevel {	×
83	if t == apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_INVALID {	×
84	return nil	×
85	}	×
86	switch t {	×
87	case apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_EVENTUAL:	×
88	return shared.QueryConsistencyLevelEventual.Ptr()	×
89	case apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_STRONG:
90	return shared.QueryConsistencyLevelStrong.Ptr()	×
91	}
92	panic("unexpected enum value")
93	}	68✔
94		68✔
95	func ContinueAsNewInitiator(t apiv1.ContinueAsNewInitiator) *shared.ContinueAsNewInitiator {	56✔
96	switch t {	56✔
97	case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_INVALID:	8✔
98	return nil	8✔
99	case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_DECIDER:	4✔
100	return shared.ContinueAsNewInitiatorDecider.Ptr()	4✔
101	case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_RETRY_POLICY:	×
102	return shared.ContinueAsNewInitiatorRetryPolicy.Ptr()	×
103	case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_CRON_SCHEDULE:
104	return shared.ContinueAsNewInitiatorCronSchedule.Ptr()	×
105	}
106	panic("unexpected enum value")
107	}	14✔
108		14✔
109	func WorkflowIDReusePolicy(t apiv1.WorkflowIdReusePolicy) *shared.WorkflowIdReusePolicy {	×
110	switch t {	×
111	case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_INVALID:	10✔
112	return nil	10✔
113	case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY:	2✔
114	return shared.WorkflowIdReusePolicyAllowDuplicateFailedOnly.Ptr()	2✔
115	case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE:	2✔
116	return shared.WorkflowIdReusePolicyAllowDuplicate.Ptr()	2✔
117	case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE:	×
118	return shared.WorkflowIdReusePolicyRejectDuplicate.Ptr()	×
119	case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING:
120	return shared.WorkflowIdReusePolicyTerminateIfRunning.Ptr()	×
121	}
122	panic("unexpected enum value")
123	}	×
124		×
125	func QueryResultType(t apiv1.QueryResultType) *shared.QueryResultType {	×
126	if t == apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID {	×
127	return nil	×
128	}	×
129	switch t {	×
130	case apiv1.QueryResultType_QUERY_RESULT_TYPE_ANSWERED:	×
131	return shared.QueryResultTypeAnswered.Ptr()	×
132	case apiv1.QueryResultType_QUERY_RESULT_TYPE_FAILED:
133	return shared.QueryResultTypeFailed.Ptr()	×
134	}
135	panic("unexpected enum value")
136	}	196✔
137		196✔
138	func ArchivalStatus(t apiv1.ArchivalStatus) *shared.ArchivalStatus {	×
139	switch t {	×
140	case apiv1.ArchivalStatus_ARCHIVAL_STATUS_INVALID:	196✔
141	return nil	196✔
142	case apiv1.ArchivalStatus_ARCHIVAL_STATUS_DISABLED:	×
143	return shared.ArchivalStatusDisabled.Ptr()	×
144	case apiv1.ArchivalStatus_ARCHIVAL_STATUS_ENABLED:
145	return shared.ArchivalStatusEnabled.Ptr()	×
146	}
147	panic("unexpected enum value")
148	}	14✔
149		14✔
150	func ParentClosePolicy(t apiv1.ParentClosePolicy) *shared.ParentClosePolicy {	×
151	switch t {	×
152	case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_INVALID:	1✔
153	return nil	1✔
154	case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_ABANDON:	×
155	return shared.ParentClosePolicyAbandon.Ptr()	×
156	case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_REQUEST_CANCEL:	13✔
157	return shared.ParentClosePolicyRequestCancel.Ptr()	13✔
158	case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_TERMINATE:
159	return shared.ParentClosePolicyTerminate.Ptr()	×
160	}
161	panic("unexpected enum value")
162	}	×
163		×
164	func DecisionTaskFailedCause(t apiv1.DecisionTaskFailedCause) *shared.DecisionTaskFailedCause {	×
165	switch t {	×
166	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_INVALID:	×
167	return nil	×
168	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_UNHANDLED_DECISION:	×
169	return shared.DecisionTaskFailedCauseUnhandledDecision.Ptr()	×
170	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SCHEDULE_ACTIVITY_ATTRIBUTES:	×
171	return shared.DecisionTaskFailedCauseBadScheduleActivityAttributes.Ptr()	×
172	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_REQUEST_CANCEL_ACTIVITY_ATTRIBUTES:	×
173	return shared.DecisionTaskFailedCauseBadRequestCancelActivityAttributes.Ptr()	×
174	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_START_TIMER_ATTRIBUTES:	×
175	return shared.DecisionTaskFailedCauseBadStartTimerAttributes.Ptr()	×
176	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_CANCEL_TIMER_ATTRIBUTES:	×
177	return shared.DecisionTaskFailedCauseBadCancelTimerAttributes.Ptr()	×
178	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_RECORD_MARKER_ATTRIBUTES:	×
179	return shared.DecisionTaskFailedCauseBadRecordMarkerAttributes.Ptr()	×
180	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_COMPLETE_WORKFLOW_EXECUTION_ATTRIBUTES:	×
181	return shared.DecisionTaskFailedCauseBadCompleteWorkflowExecutionAttributes.Ptr()	×
182	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_FAIL_WORKFLOW_EXECUTION_ATTRIBUTES:	×
183	return shared.DecisionTaskFailedCauseBadFailWorkflowExecutionAttributes.Ptr()	×
184	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_CANCEL_WORKFLOW_EXECUTION_ATTRIBUTES:	×
185	return shared.DecisionTaskFailedCauseBadCancelWorkflowExecutionAttributes.Ptr()	×
186	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_ATTRIBUTES:	×
187	return shared.DecisionTaskFailedCauseBadRequestCancelExternalWorkflowExecutionAttributes.Ptr()	×
188	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_CONTINUE_AS_NEW_ATTRIBUTES:	×
189	return shared.DecisionTaskFailedCauseBadContinueAsNewAttributes.Ptr()	×
190	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_START_TIMER_DUPLICATE_ID:	×
191	return shared.DecisionTaskFailedCauseStartTimerDuplicateID.Ptr()	×
192	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_RESET_STICKY_TASK_LIST:	×
193	return shared.DecisionTaskFailedCauseResetStickyTasklist.Ptr()	×
194	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_WORKFLOW_WORKER_UNHANDLED_FAILURE:	×
195	return shared.DecisionTaskFailedCauseWorkflowWorkerUnhandledFailure.Ptr()	×
196	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SIGNAL_WORKFLOW_EXECUTION_ATTRIBUTES:	×
197	return shared.DecisionTaskFailedCauseBadSignalWorkflowExecutionAttributes.Ptr()	×
198	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_START_CHILD_EXECUTION_ATTRIBUTES:	×
199	return shared.DecisionTaskFailedCauseBadStartChildExecutionAttributes.Ptr()	×
200	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_FORCE_CLOSE_DECISION:	×
201	return shared.DecisionTaskFailedCauseForceCloseDecision.Ptr()	×
202	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_FAILOVER_CLOSE_DECISION:	×
203	return shared.DecisionTaskFailedCauseFailoverCloseDecision.Ptr()	×
204	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SIGNAL_INPUT_SIZE:	×
205	return shared.DecisionTaskFailedCauseBadSignalInputSize.Ptr()	×
206	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_RESET_WORKFLOW:	×
207	return shared.DecisionTaskFailedCauseResetWorkflow.Ptr()	×
208	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_BINARY:	×
209	return shared.DecisionTaskFailedCauseBadBinary.Ptr()	×
210	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_SCHEDULE_ACTIVITY_DUPLICATE_ID:	×
211	return shared.DecisionTaskFailedCauseScheduleActivityDuplicateID.Ptr()	×
212	case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SEARCH_ATTRIBUTES:
213	return shared.DecisionTaskFailedCauseBadSearchAttributes.Ptr()	×
214	}
215	panic("unexpected enum value")
216	}	3✔
217		3✔
218	func WorkflowExecutionCloseStatus(t apiv1.WorkflowExecutionCloseStatus) *shared.WorkflowExecutionCloseStatus {	1✔
219	switch t {	1✔
220	case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_INVALID:	×
221	return nil	×
222	case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_COMPLETED:	×
223	return shared.WorkflowExecutionCloseStatusCompleted.Ptr()	×
224	case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_FAILED:	1✔
225	return shared.WorkflowExecutionCloseStatusFailed.Ptr()	1✔
226	case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_CANCELED:	1✔
227	return shared.WorkflowExecutionCloseStatusCanceled.Ptr()	1✔
228	case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_TERMINATED:	×
229	return shared.WorkflowExecutionCloseStatusTerminated.Ptr()	×
230	case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_CONTINUED_AS_NEW:	×
231	return shared.WorkflowExecutionCloseStatusContinuedAsNew.Ptr()	×
232	case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_TIMED_OUT:
233	return shared.WorkflowExecutionCloseStatusTimedOut.Ptr()	×
234	}
235	panic("unexpected enum value")
236	}	×
237		×
238	func QueryTaskCompletedType(t apiv1.QueryResultType) *shared.QueryTaskCompletedType {	×
239	if t == apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID {	×
240	return nil	×
241	}	×
242	switch t {	×
243	case apiv1.QueryResultType_QUERY_RESULT_TYPE_ANSWERED:	×
244	return shared.QueryTaskCompletedTypeCompleted.Ptr()	×
245	case apiv1.QueryResultType_QUERY_RESULT_TYPE_FAILED:
246	return shared.QueryTaskCompletedTypeFailed.Ptr()	×
247	}
248	panic("unexpected enum value")
249	}	98✔
250		98✔
251	func DomainStatus(t apiv1.DomainStatus) *shared.DomainStatus {	×
252	switch t {	×
253	case apiv1.DomainStatus_DOMAIN_STATUS_INVALID:	98✔
254	return nil	98✔
255	case apiv1.DomainStatus_DOMAIN_STATUS_REGISTERED:	×
256	return shared.DomainStatusRegistered.Ptr()	×
257	case apiv1.DomainStatus_DOMAIN_STATUS_DEPRECATED:	×
258	return shared.DomainStatusDeprecated.Ptr()	×
259	case apiv1.DomainStatus_DOMAIN_STATUS_DELETED:
260	return shared.DomainStatusDeleted.Ptr()	×
261	}
262	panic("unexpected enum value")
263	}	3✔
264		3✔
265	func PendingActivityState(t apiv1.PendingActivityState) *shared.PendingActivityState {	×
266	switch t {	×
267	case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_INVALID:	×
268	return nil	×
269	case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_SCHEDULED:	2✔
270	return shared.PendingActivityStateScheduled.Ptr()	2✔
271	case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_STARTED:	1✔
272	return shared.PendingActivityStateStarted.Ptr()	1✔
273	case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_CANCEL_REQUESTED:
274	return shared.PendingActivityStateCancelRequested.Ptr()	×
275	}
276	panic("unexpected enum value")
277	}	×
278		×
279	func PendingDecisionState(t apiv1.PendingDecisionState) *shared.PendingDecisionState {	×
280	switch t {	×
281	case apiv1.PendingDecisionState_PENDING_DECISION_STATE_INVALID:	×
282	return nil	×
283	case apiv1.PendingDecisionState_PENDING_DECISION_STATE_SCHEDULED:	×
284	return shared.PendingDecisionStateScheduled.Ptr()	×
285	case apiv1.PendingDecisionState_PENDING_DECISION_STATE_STARTED:
286	return shared.PendingDecisionStateStarted.Ptr()	×
287	}
288	panic("unexpected enum value")
289	}	×
290		×
291	func IndexedValueType(t apiv1.IndexedValueType) shared.IndexedValueType {	×
292	switch t {	×
293	case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INVALID:	×
294	panic("received IndexedValueType_INDEXED_VALUE_TYPE_INVALID")	×
295	case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_STRING:	×
296	return shared.IndexedValueTypeString	×
297	case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_KEYWORD:	×
298	return shared.IndexedValueTypeKeyword	×
299	case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INT:	×
300	return shared.IndexedValueTypeInt	×
301	case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_DOUBLE:	×
302	return shared.IndexedValueTypeDouble	×
303	case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_BOOL:	×
304	return shared.IndexedValueTypeBool	×
305	case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_DATETIME:
306	return shared.IndexedValueTypeDatetime	×
307	}
308	panic("unexpected enum value")
309	}	×
310		×
311	func EncodingType(t apiv1.EncodingType) *shared.EncodingType {	×
312	switch t {	×
313	case apiv1.EncodingType_ENCODING_TYPE_INVALID:	×
314	return nil	×
315	case apiv1.EncodingType_ENCODING_TYPE_THRIFTRW:	×
316	return shared.EncodingTypeThriftRW.Ptr()	×
317	case apiv1.EncodingType_ENCODING_TYPE_JSON:	×
318	return shared.EncodingTypeJSON.Ptr()	×
319	case apiv1.EncodingType_ENCODING_TYPE_PROTO3:
320	panic("not supported yet")	×
321	}
322	panic("unexpected enum value")
323	}	3✔
324		3✔
325	func TimeoutType(t apiv1.TimeoutType) *shared.TimeoutType {	×
326	switch t {	×
327	case apiv1.TimeoutType_TIMEOUT_TYPE_INVALID:	2✔
328	return nil	2✔
329	case apiv1.TimeoutType_TIMEOUT_TYPE_START_TO_CLOSE:	×
330	return shared.TimeoutTypeStartToClose.Ptr()	×
331	case apiv1.TimeoutType_TIMEOUT_TYPE_SCHEDULE_TO_START:	×
332	return shared.TimeoutTypeScheduleToStart.Ptr()	×
333	case apiv1.TimeoutType_TIMEOUT_TYPE_SCHEDULE_TO_CLOSE:	1✔
334	return shared.TimeoutTypeScheduleToClose.Ptr()	1✔
335	case apiv1.TimeoutType_TIMEOUT_TYPE_HEARTBEAT:
336	return shared.TimeoutTypeHeartbeat.Ptr()	×
337	}
338	panic("unexpected enum value")
339	}	×
340		×
341	func DecisionTaskTimedOutCause(t apiv1.DecisionTaskTimedOutCause) *shared.DecisionTaskTimedOutCause {	×
342	switch t {	×
343	case apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_INVALID:	×
344	return nil	×
345	case apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_TIMEOUT:	×
346	return shared.DecisionTaskTimedOutCauseTimeout.Ptr()	×
347	case apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_RESET:
348	return shared.DecisionTaskTimedOutCauseReset.Ptr()	×
349	}
350	panic("unexpected enum value")
351	}	×
352		×
353	func CancelExternalWorkflowExecutionFailedCause(t apiv1.CancelExternalWorkflowExecutionFailedCause) *shared.CancelExternalWorkflowExecutionFailedCause {	×
354	switch t {	×
355	case apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID:	×
356	return nil	×
357	case apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION:
358	return shared.CancelExternalWorkflowExecutionFailedCauseUnknownExternalWorkflowExecution.Ptr()	×
359	case apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED:
360	return shared.CancelExternalWorkflowExecutionFailedCauseWorkflowAlreadyCompleted.Ptr()
361	}	×
362	panic("unexpected enum value")	×
363	}	×
364		×
365	func SignalExternalWorkflowExecutionFailedCause(t apiv1.SignalExternalWorkflowExecutionFailedCause) *shared.SignalExternalWorkflowExecutionFailedCause {	×
366	switch t {	×
367	case apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID:
368	return nil	×
369	case apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION:
370	return shared.SignalExternalWorkflowExecutionFailedCauseUnknownExternalWorkflowExecution.Ptr()
371	case apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED:	2✔
372	return shared.SignalExternalWorkflowExecutionFailedCauseWorkflowAlreadyCompleted.Ptr()	2✔
373	}	×
374	panic("unexpected enum value")	×
375	}	2✔
376		2✔
377	func ChildWorkflowExecutionFailedCause(t apiv1.ChildWorkflowExecutionFailedCause) *shared.ChildWorkflowExecutionFailedCause {
378	switch t {	×
379	case apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID:
380	return nil
381	case apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING:
382	return shared.ChildWorkflowExecutionFailedCauseWorkflowAlreadyRunning.Ptr()
383	}
384	panic("unexpected enum value")
385	}
386
387	func CronOverlapPolicy(t apiv1.CronOverlapPolicy) *shared.CronOverlapPolicy {
388	switch t {
389	case apiv1.CronOverlapPolicy_CRON_OVERLAP_POLICY_INVALID:
390	return nil
391	case apiv1.CronOverlapPolicy_CRON_OVERLAP_POLICY_SKIPPED:
392	return shared.CronOverlapPolicySkipped.Ptr()
393	case apiv1.CronOverlapPolicy_CRON_OVERLAP_POLICY_BUFFER_ONE:
394	return shared.CronOverlapPolicyBufferone.Ptr()
395	}
396	// we treat any unknown value as invalid
397	return nil
398	}
399
400	func ActiveClusterSelectionStrategy(t apiv1.ActiveClusterSelectionStrategy) *shared.ActiveClusterSelectionStrategy {
401	switch t {
402	case apiv1.ActiveClusterSelectionStrategy_ACTIVE_CLUSTER_SELECTION_STRATEGY_INVALID:
403	return nil
404	case apiv1.ActiveClusterSelectionStrategy_ACTIVE_CLUSTER_SELECTION_STRATEGY_REGION_STICKY:
405	return shared.ActiveClusterSelectionStrategyRegionSticky.Ptr()
406	case apiv1.ActiveClusterSelectionStrategy_ACTIVE_CLUSTER_SELECTION_STRATEGY_EXTERNAL_ENTITY:
407	return shared.ActiveClusterSelectionStrategyExternalEntity.Ptr()
408	}
409	// we treat any unknown value as invalid
410	return nil
411	}

uber-go / cadence-client / 018c00e0-d6d2-44e5-aa77-74f47be0fdb8

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous