| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package nmxutil |
| |
| import ( |
| "fmt" |
| ) |
| |
| // Represents a application-layer timeout (e.g., NMP or CoAP); request sent, |
| // but no response received. |
| type RspTimeoutError struct { |
| Text string |
| } |
| |
| func NewRspTimeoutError(text string) *RspTimeoutError { |
| return &RspTimeoutError{ |
| Text: text, |
| } |
| } |
| |
| func FmtRspTimeoutError(format string, args ...interface{}) *RspTimeoutError { |
| return NewRspTimeoutError(fmt.Sprintf(format, args...)) |
| } |
| |
| func (e *RspTimeoutError) Error() string { |
| return e.Text |
| } |
| |
| func IsRspTimeout(err error) bool { |
| _, ok := err.(*RspTimeoutError) |
| return ok |
| } |
| |
| type BleSesnDisconnectError struct { |
| Text string |
| Reason int |
| } |
| |
| func NewBleSesnDisconnectError(reason int, |
| text string) *BleSesnDisconnectError { |
| |
| return &BleSesnDisconnectError{ |
| Reason: reason, |
| Text: text, |
| } |
| } |
| |
| func (e *BleSesnDisconnectError) Error() string { |
| return e.Text |
| } |
| |
| func IsBleSesnDisconnect(err error) bool { |
| _, ok := err.(*BleSesnDisconnectError) |
| return ok |
| } |
| |
| type SesnAlreadyOpenError struct { |
| Text string |
| } |
| |
| func NewSesnAlreadyOpenError(text string) *SesnAlreadyOpenError { |
| return &SesnAlreadyOpenError{ |
| Text: text, |
| } |
| } |
| |
| func (e *SesnAlreadyOpenError) Error() string { |
| return e.Text |
| } |
| |
| func IsSesnAlreadyOpen(err error) bool { |
| _, ok := err.(*SesnAlreadyOpenError) |
| return ok |
| } |
| |
| type SesnClosedError struct { |
| Text string |
| } |
| |
| func NewSesnClosedError(text string) *SesnClosedError { |
| return &SesnClosedError{ |
| Text: text, |
| } |
| } |
| |
| func (e *SesnClosedError) Error() string { |
| return e.Text |
| } |
| |
| func IsSesnClosed(err error) bool { |
| _, ok := err.(*SesnClosedError) |
| return ok |
| } |
| |
| type ScanTmoError struct { |
| Text string |
| } |
| |
| func NewScanTmoError(text string) *ScanTmoError { |
| return &ScanTmoError{ |
| Text: text, |
| } |
| } |
| |
| func (e *ScanTmoError) Error() string { |
| return e.Text |
| } |
| |
| func IsScanTmo(err error) bool { |
| _, ok := err.(*ScanTmoError) |
| return ok |
| } |
| |
| // Represents a low-level transport error. |
| type XportError struct { |
| Text string |
| } |
| |
| func NewXportError(text string) *XportError { |
| return &XportError{text} |
| } |
| |
| func (e *XportError) Error() string { |
| return e.Text |
| } |
| |
| func IsXport(err error) bool { |
| if err == nil { |
| return false |
| } |
| |
| _, ok := err.(*XportError) |
| return ok |
| } |
| |
| type BleHostError struct { |
| Text string |
| Status int |
| } |
| |
| func NewBleHostError(status int, text string) *BleHostError { |
| return &BleHostError{ |
| Status: status, |
| Text: text, |
| } |
| } |
| |
| func FmtBleHostError(status int, format string, |
| args ...interface{}) *BleHostError { |
| |
| return NewBleHostError(status, fmt.Sprintf(format, args...)) |
| } |
| |
| func (e *BleHostError) Error() string { |
| return e.Text |
| } |
| |
| func IsBleHost(err error) bool { |
| _, ok := err.(*BleHostError) |
| return ok |
| } |
| |
| func ToBleHost(err error) *BleHostError { |
| if berr, ok := err.(*BleHostError); ok { |
| return berr |
| } else { |
| return nil |
| } |
| } |
| |
| // Indicates an attempt to transition to the already-current state. |
| type AlreadyError struct { |
| Text string |
| } |
| |
| func NewAlreadyError(text string) *AlreadyError { |
| return &AlreadyError{text} |
| } |
| |
| func (err *AlreadyError) Error() string { |
| return err.Text |
| } |
| |
| func IsAlready(err error) bool { |
| if err == nil { |
| return false |
| } |
| |
| _, ok := err.(*AlreadyError) |
| return ok |
| } |
| |
| // Represents a BLE pairing failure due to missing or mismatched key material. |
| type BleSecurityError struct { |
| Text string |
| } |
| |
| func NewBleSecurityError(text string) *BleSecurityError { |
| return &BleSecurityError{text} |
| } |
| |
| func (err *BleSecurityError) Error() string { |
| return err.Text |
| } |
| |
| func IsBleSecurity(err error) bool { |
| if err == nil { |
| return false |
| } |
| |
| _, ok := err.(*BleSecurityError) |
| return ok |
| } |
| |
| func ToBleSecurity(err error) *BleSecurityError { |
| if berr, ok := err.(*BleSecurityError); ok { |
| return berr |
| } else { |
| return nil |
| } |
| } |