117 lines
1.9 KiB
Go
117 lines
1.9 KiB
Go
package netmap
|
|
|
|
import (
|
|
"github.com/nspcc-dev/neofs-api-go/v2/netmap"
|
|
)
|
|
|
|
// Operation is an enumeration of v2-compatible filtering operations.
|
|
type Operation uint32
|
|
|
|
const (
|
|
_ Operation = iota
|
|
|
|
// OpEQ is an "Equal" operation.
|
|
OpEQ
|
|
|
|
// OpNE is a "Not equal" operation.
|
|
OpNE
|
|
|
|
// OpGT is a "Greater than" operation.
|
|
OpGT
|
|
|
|
// OpGE is a "Greater than or equal to" operation.
|
|
OpGE
|
|
|
|
// OpLT is a "Less than" operation.
|
|
OpLT
|
|
|
|
// OpLE is a "Less than or equal to" operation.
|
|
OpLE
|
|
|
|
// OpOR is an "OR" operation.
|
|
OpOR
|
|
|
|
// OpAND is an "AND" operation.
|
|
OpAND
|
|
)
|
|
|
|
// OperationFromV2 converts v2 Operation to Operation.
|
|
func OperationFromV2(op netmap.Operation) Operation {
|
|
switch op {
|
|
default:
|
|
return 0
|
|
case netmap.OR:
|
|
return OpOR
|
|
case netmap.AND:
|
|
return OpAND
|
|
case netmap.GE:
|
|
return OpGE
|
|
case netmap.GT:
|
|
return OpGT
|
|
case netmap.LE:
|
|
return OpLE
|
|
case netmap.LT:
|
|
return OpLT
|
|
case netmap.EQ:
|
|
return OpEQ
|
|
case netmap.NE:
|
|
return OpNE
|
|
}
|
|
}
|
|
|
|
// ToV2 converts Operation to v2 Operation.
|
|
func (op Operation) ToV2() netmap.Operation {
|
|
switch op {
|
|
default:
|
|
return netmap.UnspecifiedOperation
|
|
case OpOR:
|
|
return netmap.OR
|
|
case OpAND:
|
|
return netmap.AND
|
|
case OpGE:
|
|
return netmap.GE
|
|
case OpGT:
|
|
return netmap.GT
|
|
case OpLE:
|
|
return netmap.LE
|
|
case OpLT:
|
|
return netmap.LT
|
|
case OpEQ:
|
|
return netmap.EQ
|
|
case OpNE:
|
|
return netmap.NE
|
|
}
|
|
}
|
|
|
|
// String returns string representation of Operation.
|
|
//
|
|
// String mapping:
|
|
// * OpNE: NE;
|
|
// * OpEQ: EQ;
|
|
// * OpLT: LT;
|
|
// * OpLE: LE;
|
|
// * OpGT: GT;
|
|
// * OpGE: GE;
|
|
// * OpAND: AND;
|
|
// * OpOR: OR;
|
|
// * default: OPERATION_UNSPECIFIED.
|
|
func (op Operation) String() string {
|
|
return op.ToV2().String()
|
|
}
|
|
|
|
// FromString parses Operation from a string representation.
|
|
// It is a reverse action to String().
|
|
//
|
|
// Returns true if s was parsed successfully.
|
|
func (op *Operation) FromString(s string) bool {
|
|
var g netmap.Operation
|
|
|
|
ok := g.FromString(s)
|
|
|
|
if ok {
|
|
*op = OperationFromV2(g)
|
|
}
|
|
|
|
return ok
|
|
}
|