model_channel_event_detail.go

/*
traQ v3

traQ v3 API

API version: 3.0
*/

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package traq

import (
	"encoding/json"
	"fmt"
)

// ChannelEventDetail - イベント内容
type ChannelEventDetail struct {
	ChildCreatedEvent              *ChildCreatedEvent
	ForcedNotificationChangedEvent *ForcedNotificationChangedEvent
	NameChangedEvent               *NameChangedEvent
	ParentChangedEvent             *ParentChangedEvent
	PinAddedEvent                  *PinAddedEvent
	PinRemovedEvent                *PinRemovedEvent
	SubscribersChangedEvent        *SubscribersChangedEvent
	TopicChangedEvent              *TopicChangedEvent
	VisibilityChangedEvent         *VisibilityChangedEvent
}

// ChildCreatedEventAsChannelEventDetail is a convenience function that returns ChildCreatedEvent wrapped in ChannelEventDetail
func ChildCreatedEventAsChannelEventDetail(v *ChildCreatedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		ChildCreatedEvent: v,
	}
}

// ForcedNotificationChangedEventAsChannelEventDetail is a convenience function that returns ForcedNotificationChangedEvent wrapped in ChannelEventDetail
func ForcedNotificationChangedEventAsChannelEventDetail(v *ForcedNotificationChangedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		ForcedNotificationChangedEvent: v,
	}
}

// NameChangedEventAsChannelEventDetail is a convenience function that returns NameChangedEvent wrapped in ChannelEventDetail
func NameChangedEventAsChannelEventDetail(v *NameChangedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		NameChangedEvent: v,
	}
}

// ParentChangedEventAsChannelEventDetail is a convenience function that returns ParentChangedEvent wrapped in ChannelEventDetail
func ParentChangedEventAsChannelEventDetail(v *ParentChangedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		ParentChangedEvent: v,
	}
}

// PinAddedEventAsChannelEventDetail is a convenience function that returns PinAddedEvent wrapped in ChannelEventDetail
func PinAddedEventAsChannelEventDetail(v *PinAddedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		PinAddedEvent: v,
	}
}

// PinRemovedEventAsChannelEventDetail is a convenience function that returns PinRemovedEvent wrapped in ChannelEventDetail
func PinRemovedEventAsChannelEventDetail(v *PinRemovedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		PinRemovedEvent: v,
	}
}

// SubscribersChangedEventAsChannelEventDetail is a convenience function that returns SubscribersChangedEvent wrapped in ChannelEventDetail
func SubscribersChangedEventAsChannelEventDetail(v *SubscribersChangedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		SubscribersChangedEvent: v,
	}
}

// TopicChangedEventAsChannelEventDetail is a convenience function that returns TopicChangedEvent wrapped in ChannelEventDetail
func TopicChangedEventAsChannelEventDetail(v *TopicChangedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		TopicChangedEvent: v,
	}
}

// VisibilityChangedEventAsChannelEventDetail is a convenience function that returns VisibilityChangedEvent wrapped in ChannelEventDetail
func VisibilityChangedEventAsChannelEventDetail(v *VisibilityChangedEvent) ChannelEventDetail {
	return ChannelEventDetail{
		VisibilityChangedEvent: v,
	}
}

// Unmarshal JSON data into one of the pointers in the struct
func (dst *ChannelEventDetail) UnmarshalJSON(data []byte) error {
	var err error
	match := 0
	// try to unmarshal data into ChildCreatedEvent
	err = newStrictDecoder(data).Decode(&dst.ChildCreatedEvent)
	if err == nil {
		jsonChildCreatedEvent, _ := json.Marshal(dst.ChildCreatedEvent)
		if string(jsonChildCreatedEvent) == "{}" { // empty struct
			dst.ChildCreatedEvent = nil
		} else {
			match++
		}
	} else {
		dst.ChildCreatedEvent = nil
	}

	// try to unmarshal data into ForcedNotificationChangedEvent
	err = newStrictDecoder(data).Decode(&dst.ForcedNotificationChangedEvent)
	if err == nil {
		jsonForcedNotificationChangedEvent, _ := json.Marshal(dst.ForcedNotificationChangedEvent)
		if string(jsonForcedNotificationChangedEvent) == "{}" { // empty struct
			dst.ForcedNotificationChangedEvent = nil
		} else {
			match++
		}
	} else {
		dst.ForcedNotificationChangedEvent = nil
	}

	// try to unmarshal data into NameChangedEvent
	err = newStrictDecoder(data).Decode(&dst.NameChangedEvent)
	if err == nil {
		jsonNameChangedEvent, _ := json.Marshal(dst.NameChangedEvent)
		if string(jsonNameChangedEvent) == "{}" { // empty struct
			dst.NameChangedEvent = nil
		} else {
			match++
		}
	} else {
		dst.NameChangedEvent = nil
	}

	// try to unmarshal data into ParentChangedEvent
	err = newStrictDecoder(data).Decode(&dst.ParentChangedEvent)
	if err == nil {
		jsonParentChangedEvent, _ := json.Marshal(dst.ParentChangedEvent)
		if string(jsonParentChangedEvent) == "{}" { // empty struct
			dst.ParentChangedEvent = nil
		} else {
			match++
		}
	} else {
		dst.ParentChangedEvent = nil
	}

	// try to unmarshal data into PinAddedEvent
	err = newStrictDecoder(data).Decode(&dst.PinAddedEvent)
	if err == nil {
		jsonPinAddedEvent, _ := json.Marshal(dst.PinAddedEvent)
		if string(jsonPinAddedEvent) == "{}" { // empty struct
			dst.PinAddedEvent = nil
		} else {
			match++
		}
	} else {
		dst.PinAddedEvent = nil
	}

	// try to unmarshal data into PinRemovedEvent
	err = newStrictDecoder(data).Decode(&dst.PinRemovedEvent)
	if err == nil {
		jsonPinRemovedEvent, _ := json.Marshal(dst.PinRemovedEvent)
		if string(jsonPinRemovedEvent) == "{}" { // empty struct
			dst.PinRemovedEvent = nil
		} else {
			match++
		}
	} else {
		dst.PinRemovedEvent = nil
	}

	// try to unmarshal data into SubscribersChangedEvent
	err = newStrictDecoder(data).Decode(&dst.SubscribersChangedEvent)
	if err == nil {
		jsonSubscribersChangedEvent, _ := json.Marshal(dst.SubscribersChangedEvent)
		if string(jsonSubscribersChangedEvent) == "{}" { // empty struct
			dst.SubscribersChangedEvent = nil
		} else {
			match++
		}
	} else {
		dst.SubscribersChangedEvent = nil
	}

	// try to unmarshal data into TopicChangedEvent
	err = newStrictDecoder(data).Decode(&dst.TopicChangedEvent)
	if err == nil {
		jsonTopicChangedEvent, _ := json.Marshal(dst.TopicChangedEvent)
		if string(jsonTopicChangedEvent) == "{}" { // empty struct
			dst.TopicChangedEvent = nil
		} else {
			match++
		}
	} else {
		dst.TopicChangedEvent = nil
	}

	// try to unmarshal data into VisibilityChangedEvent
	err = newStrictDecoder(data).Decode(&dst.VisibilityChangedEvent)
	if err == nil {
		jsonVisibilityChangedEvent, _ := json.Marshal(dst.VisibilityChangedEvent)
		if string(jsonVisibilityChangedEvent) == "{}" { // empty struct
			dst.VisibilityChangedEvent = nil
		} else {
			match++
		}
	} else {
		dst.VisibilityChangedEvent = nil
	}

	if match > 1 { // more than 1 match
		// reset to nil
		dst.ChildCreatedEvent = nil
		dst.ForcedNotificationChangedEvent = nil
		dst.NameChangedEvent = nil
		dst.ParentChangedEvent = nil
		dst.PinAddedEvent = nil
		dst.PinRemovedEvent = nil
		dst.SubscribersChangedEvent = nil
		dst.TopicChangedEvent = nil
		dst.VisibilityChangedEvent = nil

		return fmt.Errorf("data matches more than one schema in oneOf(ChannelEventDetail)")
	} else if match == 1 {
		return nil // exactly one match
	} else { // no match
		return fmt.Errorf("data failed to match schemas in oneOf(ChannelEventDetail)")
	}
}

// Marshal data from the first non-nil pointers in the struct to JSON
func (src ChannelEventDetail) MarshalJSON() ([]byte, error) {
	if src.ChildCreatedEvent != nil {
		return json.Marshal(&src.ChildCreatedEvent)
	}

	if src.ForcedNotificationChangedEvent != nil {
		return json.Marshal(&src.ForcedNotificationChangedEvent)
	}

	if src.NameChangedEvent != nil {
		return json.Marshal(&src.NameChangedEvent)
	}

	if src.ParentChangedEvent != nil {
		return json.Marshal(&src.ParentChangedEvent)
	}

	if src.PinAddedEvent != nil {
		return json.Marshal(&src.PinAddedEvent)
	}

	if src.PinRemovedEvent != nil {
		return json.Marshal(&src.PinRemovedEvent)
	}

	if src.SubscribersChangedEvent != nil {
		return json.Marshal(&src.SubscribersChangedEvent)
	}

	if src.TopicChangedEvent != nil {
		return json.Marshal(&src.TopicChangedEvent)
	}

	if src.VisibilityChangedEvent != nil {
		return json.Marshal(&src.VisibilityChangedEvent)
	}

	return nil, nil // no data in oneOf schemas
}

// Get the actual instance
func (obj *ChannelEventDetail) GetActualInstance() interface{} {
	if obj == nil {
		return nil
	}
	if obj.ChildCreatedEvent != nil {
		return obj.ChildCreatedEvent
	}

	if obj.ForcedNotificationChangedEvent != nil {
		return obj.ForcedNotificationChangedEvent
	}

	if obj.NameChangedEvent != nil {
		return obj.NameChangedEvent
	}

	if obj.ParentChangedEvent != nil {
		return obj.ParentChangedEvent
	}

	if obj.PinAddedEvent != nil {
		return obj.PinAddedEvent
	}

	if obj.PinRemovedEvent != nil {
		return obj.PinRemovedEvent
	}

	if obj.SubscribersChangedEvent != nil {
		return obj.SubscribersChangedEvent
	}

	if obj.TopicChangedEvent != nil {
		return obj.TopicChangedEvent
	}

	if obj.VisibilityChangedEvent != nil {
		return obj.VisibilityChangedEvent
	}

	// all schemas are nil
	return nil
}

type NullableChannelEventDetail struct {
	value *ChannelEventDetail
	isSet bool
}

func (v NullableChannelEventDetail) Get() *ChannelEventDetail {
	return v.value
}

func (v *NullableChannelEventDetail) Set(val *ChannelEventDetail) {
	v.value = val
	v.isSet = true
}

func (v NullableChannelEventDetail) IsSet() bool {
	return v.isSet
}

func (v *NullableChannelEventDetail) Unset() {
	v.value = nil
	v.isSet = false
}

func NewNullableChannelEventDetail(val *ChannelEventDetail) *NullableChannelEventDetail {
	return &NullableChannelEventDetail{value: val, isSet: true}
}

func (v NullableChannelEventDetail) MarshalJSON() ([]byte, error) {
	return json.Marshal(v.value)
}

func (v *NullableChannelEventDetail) UnmarshalJSON(src []byte) error {
	v.isSet = true
	return json.Unmarshal(src, &v.value)
}