aci

var atb AttributeBindTypeOrValue
fmt.Printf("%d available aci.BindRuleMethod instances", atb.BRM().Len())

Output:

2 available aci.BindRuleMethod instances

This example demonstrates the SHA-1 hash comparison between two (2) AttributeBindTypeOrValue instances using the Compare method.

// these will eval as true (match) because the underlying
// string call does not include the Keyword. We need the
// bind rule to see that ...
attr := ABTV(BindUAT, `cACertificate`, `USERDN`)
oattr := ABTV(BindGAT, `cACertificate`, USERDN)

eqaBr := attr.Eq()
eqoBr := oattr.Eq()

fmt.Printf("Hashes are equal: %t", eqaBr.Compare(eqoBr))

Output:

Hashes are equal: false

This example demonstrates the use of the AttributeBindTypeOrValue type's Eq method, allowing for the creation of a TargetRule instance containing the receiver value, and bearing the TargetAttrFilters Keyword context.

attr := AT(`manager`)
btype := USERDN

atb := UAT(attr, btype)

fmt.Printf("%s", atb.Eq())

Output:

userattr = "manager#USERDN"

This example demonstrates a check of the receiver for "nilness".

var atb AttributeBindTypeOrValue

fmt.Printf("Is zero: %t", atb.IsZero())

Output:

Is zero: true

This example demonstrates the interrogation of the receiver in order to discern the appropriate Keyword.

Its string representation, along with the name of the Keyword type, is shown.

var atb AttributeBindTypeOrValue

fmt.Printf("Keyword is '%s' (type:%T)", atb.Keyword(), atb.Keyword())

Output:

Keyword is 'userattr' (type:aci.BindKeyword)

This example demonstrates the use of the AttributeBindTypeOrValue type's Ne method

attr := AT(`manager`)
btype := USERDN

atb := UAT(attr, btype)

fmt.Printf("%s", atb.Ne())

Output:

userattr != "manager#USERDN"

This example demonstrates the creation of an instance of AttributeBindTypeOrValue.

In this example, a raw string representation of an AttributeBindTypeOrValue instance is used for parser input.

txt := `manager#USERDN`
var atb AttributeBindTypeOrValue
err := atb.Parse(txt)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Printf("%T: %s", atb, atb)

Output:

aci.AttributeBindTypeOrValue: manager#USERDN

This example demonstrates the creation of an instance of AttributeBindTypeOrValue followed by a call of its String method through fmt.Printf.

The return value is the entirely of the receiver in string representation.

var atb AttributeBindTypeOrValue = ABTV(BindUAT)
atb.Set(AT(`manager`), USERDN)
fmt.Printf("%s value is %s", atb.Keyword(), atb)

Output:

userattr value is manager#USERDN

This example demonstrates the creation of an instance of AttributeBindTypeOrValue followed by a call of its String method through fmt.Printf. In this example, the receiver instance is populated using only string values.

The return value is the entirely of the receiver in string representation.

var atb AttributeBindTypeOrValue
atb.Set(`manager`, `USERDN`)
fmt.Printf("%s", atb)

Output:

manager#USERDN

This example demonstrates the creation of an instance of AttributeBindTypeOrValue followed by a call of its String method.

The return value is the entirely of the receiver in string representation.

var atb AttributeBindTypeOrValue
atb.Set(AT(`manager`), USERDN)
fmt.Printf("%s", atb)

Output:

manager#USERDN

This example demonstrates the creation of an instance of AttributeBindTypeOrValue followed by a call of its Valid method for the purpose of sanity checking the receiver.

An error is reported and printed to STDOUT.

var (
	atb AttributeBindTypeOrValue
	err error
)

if err = atb.Valid(); err != nil {
	fmt.Println(err)
}

Output:

aci.AttributeBindTypeOrValue instance is nil

This example demonstrates the creation of an instance of AttributeFilter followed by a call of its AttributeType method.

The return type, AttributeType, is shown in string representation.

aftxt := `homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta))`
var af AttributeFilter
_ = af.Parse(aftxt) // shadow error for brevity

fmt.Printf("%s", af.AttributeType())

Output:

homeDirectory

This example demonstrates the SHA-1 hash comparison between two (2) AttributeFilter instances using the Compare method.

f1 := AF(`objectClass`, `(|(objectClass=contractor)(objectClass=intern))`)
f2 := AF(`homeDirectory`, `(|(objectClass=contractor)(objectClass=intern))`)

fmt.Printf("Hashes are equal: %t", f1.Compare(f2))

Output:

Hashes are equal: false

This example demonstrates a check of the receiver for "nilness".

var af AttributeFilter

fmt.Printf("Is zero: %t (obviously)", af.IsZero())

Output:

Is zero: true (obviously)

This example demonstrates the interrogation of the receiver in order to discern the appropriate Keyword.

Its string representation, along with the name of the Keyword type, is shown.

var af AttributeFilter

fmt.Printf("Keyword is '%s' (type:%T)", af.Keyword(), af.Keyword())

Output:

Keyword is 'targattrfilters' (type:aci.TargetKeyword)

This example demonstrates the creation of an instance of AttributeFilter, which is strictly intended for use within instances of AttributeFilterOperation.

In this example, a raw string representation of an AttributeFilter is used for parser input.

The return type, AttributeFilter, is then interrogated by way of the AttributeFilter.AttributeType and AttributeFilter.SearchFilter methods it makes available to the user. An alternative to this approach is to simply use its String method to get the whole value, if desired.

aftxt := `objectClass:(&(objectClass=employee)(cn=Jesse Coretta))`
var af AttributeFilter
_ = af.Parse(`4537895439h`)
err := af.Parse(aftxt)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Printf("AT:%q, FILTER:%q", af.AttributeType(), af.SearchFilter())

Output:

AT:"objectClass", FILTER:"(&(objectClass=employee)(cn=Jesse Coretta))"

This example demonstrates the creation of an instance of AttributeFilter followed by a call of its SearchFilter method.

The return type, SearchFilter, is shown in string representation.

aftxt := `homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta))`
var af AttributeFilter
_ = af.Parse(aftxt) // shadow error for brevity

fmt.Printf("%s", af.SearchFilter())

Output:

(&(objectClass=employee)(cn=Jesse Coretta))

This example demonstrates the creation of an instance of AttributeFilter, which is strictly intended for use within instances of AttributeFilterOperation.

In this example, proper type instances are fed to the Set method to form a complete AttributeFilter instance.

The return type, AttributeFilter, is then shown in string representation.

var af AttributeFilter // see also the package level AF function
af.Set(
	AT(`homeDirectory`),
	Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`),
)

fmt.Printf("%s", af)

Output:

homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta))

This example demonstrates the creation of an instance of AttributeFilter followed by a call of its String method.

The return value is the entirely of the receiver in string representation.

aftxt := `homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta))`
var af AttributeFilter
_ = af.Parse(aftxt) // shadow error for brevity

fmt.Printf("%s", af)

Output:

homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta))

This example demonstrates the creation of an instance of AttributeFilter followed by a call of its Valid method for the purpose of sanity checking the receiver.

An error is reported and printed to STDOUT.

var (
	af  AttributeFilter
	err error
)

if err = af.Valid(); err != nil {
	fmt.Println(err)
}

Output:

aci.AttributeFilter instance is nil

This example demonstrates the SHA-1 hash comparison between two (2) AttributeFilterOperation instances using the Compare method.

attr := AT(`uidNumber`)
filter := Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF1 := AF(attr, filter)
aFO1 := AddOp.AFO(aF1)

attr = AT(`gidNumber`)
filter = Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF2 := AF(attr, filter)
aFO2 := DelOp.AFO(aF2)

fmt.Printf("Hashes are equal: %t", aFO1.Compare(aFO2))

Output:

Hashes are equal: false

This example demonstrates the use of the AttributeFilterOperation type's Contains method, allowing for basic text searches of the receiver.

Note that case is significant in the matching process for instances of this type.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFO := AddOp.AFO(aF1, aF2)

fmt.Printf("%t", aFO.Contains(`homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta))`))

Output:

true

This example demonstrates the use of the AttributeFilterOperation type's Eq method, allowing for the creation of a TargetRule instance containing the receiver value, and bearing the `targattrfilters` keyword context.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFO := AddOp.AFO(aF1, aF2)

fmt.Printf("%s", aFO.Eq())

Output:

( targattrfilters = "add=homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta)) && gecos:(|(objectClass=contractor)(objectClass=intern))" )

This example demonstrates the use of the AttributeFilterOperation type's F method, which returns the appropriate slice building function for convenience.

var aFO AttributeFilterOperation

// this returns the package-level AF function
Func := aFO.F()

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF := Func(attr, filter)

fmt.Printf("%s", aF)

Output:

homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta))

This example demonstrates the use of the AttributeFilterOperation type's Index method to allow iteration of the receiver's contents.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFO := AddOp.AFO(aF1, aF2)

idx := aFO.Index(1) // 2nd index in stack

fmt.Printf("%s", idx.AttributeType())

Output:

gecos

This example demonstrates a check of the receiver for "nilness" using the AttributeFilterOperation type's IsZero method.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF := AF(attr, filter)
aFO := AddOp.AFO(aF)

fmt.Printf("%t", aFO.IsZero())

Output:

false

This example demonstrates the use of the AttributeFilterOperation type's Keyword method.

var aFO AttributeFilterOperation

fmt.Printf("%s", aFO.Keyword())

Output:

targattrfilters

This example demonstrates the use of the AttributeFilterOperation type's Kind method.

var aFO AttributeFilterOperation

fmt.Printf("%s", aFO.Kind())

Output:

targattrfilters

This example demonstrates the use of the AttributeFilterOperation type's Len method to report the integer length of the receiver.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFO := AddOp.AFO(aF1, aF2)

fmt.Printf("Length: %d", aFO.Len())

Output:

Length: 2

This example demonstrates the use of the AttributeFilterOperation type's Ne method, which is not intended to be used in any situation ever. See the comments for this method for details.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
af := AF(attr, filter)
aFO := AddOp.AFO(af)

bogus := aFO.Ne()

fmt.Printf("%t", bogus.IsZero())

Output:

true

This example demonstrates a check of the receiver's operational disposition using the Operation method.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF := AF(attr, filter)
aFO := AddOp.AFO(aF)

fmt.Printf("%s", aFO.Operation())

Output:

add

This example demonstrates the creation of an instance of AttributeFilterOperation using the AttributeFilterOperation type's Parse method.

In this example, a raw string representation of an AttributeFilterOperation is used for parser input. The resultant output from the instance's String method should be identical to that which was fed into the Parse method.

af1 := `objectClass:(&(objectClass=employee)(cn=Jesse Coretta))`
af2 := `homeDirectory:(&(objectClass=accountant)(cn=Courtney Tolana))`
want := `add=` + af1 + ` && ` + af2

var afo AttributeFilterOperation
if err := afo.Parse(want); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}

fmt.Printf("%s", afo)

Output:

add=objectClass:(&(objectClass=employee)(cn=Jesse Coretta)) && homeDirectory:(&(objectClass=accountant)(cn=Courtney Tolana))

This example demonstrates the use of the AttributeFilterOperation type's Pop method to remove the last stack slice per LIFO ordering.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFO := AddOp.AFO(aF1, aF2)

popped := aFO.Pop()

fmt.Printf("%s", popped.AttributeType())

Output:

gecos

This example demonstrates the use of the AttributeFilterOperation type's Push method to append a new (eligible) instance to the receiver.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

aFO := AddOp.AFO(aF1)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFO.Push(aF2)

fmt.Printf("%s", aFO)

Output:

add=homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta)) && gecos:(|(objectClass=contractor)(objectClass=intern))

This example demonstrates the creation of an instance of AttributeFilterOperation followed by a call of its String method.

The return value is the entirely of the receiver in string representation.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFO := AddOp.AFO(aF1, aF2)

fmt.Printf("%s", aFO)

Output:

add=homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta)) && gecos:(|(objectClass=contractor)(objectClass=intern))

var afo AttributeFilterOperation
fmt.Printf("%d available aci.TargetRuleMethod instances", afo.TRM().Len())

Output:

2 available aci.TargetRuleMethod instances

This example demonstrates the creation of an instance of AttributeFilterOperation followed by a call of its Valid method for the purpose of sanity checking the receiver.

No error is reported and printed to STDOUT in this case, as the instance is valid.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF := AF(attr, filter)
aFO := AddOp.AFO(aF)

fmt.Printf("%t", aFO.Valid() == nil)

Output:

true

This example demonstrates the SHA-1 hash comparison between two (2) AttributeFilterOperations instances using the Compare method.

The comparison returns false, as the compared instances are ordered differently.

attr := AT(`uidNumber`)
filter := Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF1 := AF(attr, filter)
aFO1 := AddOp.AFO(aF1)

attr = AT(`gidNumber`)
filter = Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF2 := AF(attr, filter)
aFO2 := DelOp.AFO(aF2)

// Create the second AttributeFilterOperation
// instance (aFO2)
var afos1 AttributeFilterOperations = AFOs()
afos1.Push(aFO1, aFO2)

var afos2 AttributeFilterOperations = AFOs()
afos2.Push(aFO2, aFO1)

fmt.Printf("Hashes are equal: %t", afos1.Compare(afos2))

Output:

Hashes are equal: false

This example demonstrates the creation of an instance of AttributeFilterOperations, which is used to store individual AttributeFilterOperation instances.

In this example, proper type instances are fed to the package level AFOs function to form a complete AttributeFilterOperations instance.

The return type, AttributeFilterOperations, is then shown in string representation.

// define the desired attributeType
// and filter for the first element
attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

// Create the first AttributeFilterOperation
// instance (aFO1)
aFO1 := AddOp.AFO(aF1, aF2)

attr = AT(`uidNumber`)
filter = Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF3 := AF(attr, filter)

attr = AT(`gidNumber`)
filter = Filter(`(objectClass=account)`)
aF4 := AF(attr, filter)

// Create the second AttributeFilterOperation
// instance (aFO2)
aFO2 := DelOp.AFO(aF3, aF4)

// prepare our AttributeFilterOperations
// instance stack (aFOs) using the AFOs
// package level function. Push both of
// the above AFO instances.
aFOs := AFOs(aFO1, aFO2)

fmt.Printf("%t", aFOs.Contains(`delete=uidNumber:(&(objectClass=accounting)(terminated=FALSE)) && gidNumber:(objectClass=account)`))

Output:

true

This example demonstrates the use of the AttributeFilterOperations type's Eq method, allowing for the creation of a TargetRule instance containing the receiver value, and bearing the `targattrfilters` keyword context.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFO := AddOp.AFO(aF1, aF2)

// all of the above was copied verbatim
// from the AttributeFilterOperation Eq
// example. All we're really doing here
// is enveloping it in another stack
aFOs := AFOs(aFO)

fmt.Printf("%s", aFOs.Eq())

Output:

( targattrfilters = "add=homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta)) && gecos:(|(objectClass=contractor)(objectClass=intern))" )

This example demonstrates the use of the AttributeFilterOperations type's F method, which returns the appropriate slice building function for convenience.

var aFOs AttributeFilterOperations

// this returns the package-level AFO function
Func := aFOs.F()

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF := Func(attr, filter)
aFO := Func(aF)

fmt.Printf("%T", aFO)

Output:

aci.AttributeFilterOperation

This example demonstrates the use of the AttributeFilterOperations type's Index method to allow iteration of the receiver's contents.

// define the desired attributeType
// and filter for the first element
attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

// Create the first AttributeFilterOperation
// instance (aFO1)
aFO1 := AddOp.AFO(aF1, aF2)

attr = AT(`uidNumber`)
filter = Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF3 := AF(attr, filter)

attr = AT(`gidNumber`)
filter = Filter(`(objectClass=account)`)
aF4 := AF(attr, filter)

// Create the second AttributeFilterOperation
// instance (aFO2)
aFO2 := DelOp.AFO(aF3, aF4)

// prepare our AttributeFilterOperations
// instance stack (aFOs) using the AFOs
// package level function. Push both of
// the above AFO instances.
aFOs := AFOs(aFO1, aFO2)

slice := aFOs.Index(1)

fmt.Printf("%s", slice)

Output:

delete=uidNumber:(&(objectClass=accounting)(terminated=FALSE)) && gidNumber:(objectClass=account)

This example demonstrates a check of the receiver for "nilness" using the AttributeFilterOperations type's IsZero method.

var afo AttributeFilterOperations
fmt.Printf("%t", afo.IsZero())

Output:

true

This example demonstrates the use of the AttributeFilterOperations type's Keyword method.

var afos AttributeFilterOperations

fmt.Printf("%s", afos.Keyword())

Output:

targattrfilters

This example demonstrates the use of the AttributeFilterOperations type's Kind method.

var aFOs AttributeFilterOperations

fmt.Printf("%s", aFOs.Kind())

Output:

targattrfilters

This example demonstrates the use of the AttributeFilterOperation type's Len method to report the integer length of the receiver.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFOs := AFOs(AddOp.AFO(aF1, aF2))

fmt.Printf("Length: %d", aFOs.Len())

Output:

Length: 1

This example demonstrates the use of the AttributeFilterOperation type's Ne method, which is not intended to be used in any situation ever. See the comments for this method for details.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
af := AF(attr, filter)
aFO := AddOp.AFO(af)

// all of the above was copied verbatim
// from the AttributeFilterOperation Ne
// example. All we're really doing here
// is enveloping it in another stack
aFOs := AFOs(aFO)
bogus := aFOs.Ne()

fmt.Printf("%t", bogus.IsZero())

Output:

true

This example demonstrates the creation of an instance of AttributeFilterOperations using the AttributeFilterOperations type's Parse method.

In this example, a raw string representation of an AttributeFilterOperations is used for parser input. The resultant output from the instance's String method should be identical to that which was fed into the Parse method.

aftxt := `delete=objectClass:(&(objectClass=employee)(cn=Jesse Coretta)) && homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta))`
var afos AttributeFilterOperations
err := afos.Parse(aftxt)
if err != nil {
	fmt.Println(err) // always check your parser errors
	return
}
got := afos.String()

fmt.Printf("Values match: %t", got == aftxt)

Output:

Values match: true

This example demonstrates the use of the AttributeFilterOperations type's Pop method to remove the last stack slice per LIFO ordering.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

aFOs := AFOs(DelOp.AFO(aF1, aF2))

popped := aFOs.Pop()

fmt.Printf("%s", popped)

Output:

delete=homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta)) && gecos:(|(objectClass=contractor)(objectClass=intern))

This example demonstrates the use of the AttributeFilterOperations type's Push method to append a new (eligible) instance to the receiver.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

var afos AttributeFilterOperations = AFOs()
afos.Push(AddOp.AFO(aF1, aF2))

fmt.Printf("%d", afos.Len())

Output:

1

This example demonstrates the use of the AttributeFilterOperations type's Push method to append a new (eligible) instance to the receiver.

attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

var afos AttributeFilterOperations = AFOs()
ad := AddOp.AFO(aF1, aF2)
afos.Push(ad.String())

fmt.Printf("%d", afos.Index(0).Len())

Output:

2

// define the desired attributeType
// and filter for the first element
attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

// Create the first AttributeFilterOperation
// instance (aFO1)
aFO1 := AddOp.AFO(aF1, aF2)

attr = AT(`uidNumber`)
filter = Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF3 := AF(attr, filter)

attr = AT(`gidNumber`)
filter = Filter(`(objectClass=account)`)
aF4 := AF(attr, filter)

// Create the second AttributeFilterOperation
// instance (aFO2)
aFO2 := DelOp.AFO(aF3, aF4)

// prepare our AttributeFilterOperations
// instance stack (aFOs) using the AFOs
// package level function. Push both of
// the above AFO instances, and set a
// delimiter other than the default...
delimiter := AttributeFilterOperationsSemiDelim

aFOs := AFOs(aFO1, aFO2).SetDelimiter(delimiter)
fmt.Printf("%s", aFOs)

Output:

add=homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta)) && gecos:(|(objectClass=contractor)(objectClass=intern));delete=uidNumber:(&(objectClass=accounting)(terminated=FALSE)) && gidNumber:(objectClass=account)

// define the desired attributeType
// and filter for the first element
attr := AT(`homeDirectory`)
filter := Filter(`(&(objectClass=employee)(cn=Jesse Coretta))`)
aF1 := AF(attr, filter)

attr = AT(`gecos`)
filter = Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF2 := AF(attr, filter)

// Create the first AttributeFilterOperation
// instance (aFO1)
aFO1 := AddOp.AFO(aF1, aF2)

attr = AT(`uidNumber`)
filter = Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF3 := AF(attr, filter)

attr = AT(`gidNumber`)
filter = Filter(`(objectClass=account)`)
aF4 := AF(attr, filter)

// Create the second AttributeFilterOperation
// instance (aFO2)
aFO2 := DelOp.AFO(aF3, aF4)

// prepare our AttributeFilterOperations
// instance stack (aFOs) using the AFOs
// package level function. Push both of
// the above AFO instances

aFOs := AFOs(aFO1, aFO2)
fmt.Printf("%s", aFOs)

Output:

add=homeDirectory:(&(objectClass=employee)(cn=Jesse Coretta)) && gecos:(|(objectClass=contractor)(objectClass=intern)),delete=uidNumber:(&(objectClass=accounting)(terminated=FALSE)) && gidNumber:(objectClass=account)

var afos AttributeFilterOperations
fmt.Printf("%d available aci.TargetRuleMethod instances", afos.TRM().Len())

Output:

2 available aci.TargetRuleMethod instances

This example demonstrates the creation of an instance of AttributeFilterOperations followed by a call of its Valid method for the purpose of sanity checking the receiver.

attr := AT(`uidNumber`)
filter := Filter(`(&(objectClass=accounting)(terminated=FALSE))`)
aF1 := AF(attr, filter)

attr = AT(`gidNumber`)
filter = Filter(`(objectClass=account)`)
aF2 := AF(attr, filter)

// Create the second AttributeFilterOperation
// instance (aFO2)
var afos AttributeFilterOperations = AFOs()
afos.Push(DelOp.AFO(aF1, aF2))

fmt.Printf("Valid: %t", afos.Valid() == nil)

Output:

Valid: true

This example demonstrates the creation of an instance of AttributeFilterOperation, which is strictly intended for use within instances of AttributeFilterOperations.

In this example, proper type instances are fed to the AttributeOperation AFO method to form a complete AttributeFilterOperation instance.

The return type, AttributeFilterOperation, has its type shown in text, along with the current stack length.

attr := AT(`gecos`)
filter := Filter(`(|(objectClass=contractor)(objectClass=intern))`)
aF := AF(attr, filter)

// Create the first AttributeFilterOperation
// instance (aFO1)
aFO := AddOp.AFO(aF)

fmt.Printf("%T [len:%d]", aFO, aFO.Len())

Output:

aci.AttributeFilterOperation [len:1]

This example demonstrates the string representation of an AttributeOperation constant. In this example, the instance is shown in string representation.

fmt.Printf("%s and %s", AddOp, DelOp)

Output:

add and delete

This example demonstrates the SHA-1 hash comparison between two (2) AttributeType instances using the Compare method.

attr := AT(`cACertificate`)
oattr := AT(`cacertificate`)

fmt.Printf("Hashes are equal: %t", oattr.Compare(attr))

Output:

Hashes are equal: false

This example demonstrates the creation of an equality TargetRule (TargetAttr) using the receiver instance as input:

attr := AT(`*`)
fmt.Printf("%s", attr.Eq())

Output:

( targetattr = "*" )

This example demonstrates a check of the receiver for "nilness".

fmt.Printf("%t", AT(`owner`).IsZero())

Output:

false

This example demonstrates the use of the useless Keyword method, as AttributeType instances do not have any knowledge of Keyword instances at this time.

fmt.Printf("%v", AT(`owner`).Keyword())

Output:

<nil>

This example demonstrates the use of the useless Kind method, as this information is normally derived from a Keyword, which the receiver does not have.

fmt.Printf("'%s'", AT(`owner`).Kind())

Output:

''

This example demonstrates the use of the useless Len method, as this information is only made available to satisfy Go's interface signature requirements as they pertain to the AttributeTypeContext interface.

fmt.Printf("%d", AT(`owner`).Len())

Output:

1

This example demonstrates the creation of a negated equality TargetRule (TargetAttr) using the receiver instance as input:

attr := AT(`aci`)
fmt.Printf("%s", attr.Ne())

Output:

( targetattr != "aci" )

This example demonstrates the string representation of the receiver instance.

fmt.Printf("%s", AT(`owner`))

Output:

owner

This example demonstrates how a caller can determine the number of ComparisonOperator-related methods are available for use by the receiver instance.

var at AttributeType
fmt.Printf("%d available aci.BindRuleMethod instances", at.TRM().Len())

Output:

2 available aci.BindRuleMethod instances

This example demonstrates a check of the receiver for an aberrant state.

fmt.Printf("Valid: %t", AT(`owner`).Valid() == nil)

Output:

Valid: true

This example demonstrates a basic SHA-1 hash comparison between two like instances of the receiver's type.

attrs1 := TAs(`cn`, `givenName`, `sn`, `objectClass`, `l`)
attrs2 := TAs(`cn`, `givenName`, `sn`, `objectClass`, `l`)

fmt.Printf("%T instances match: %t", attrs1, attrs1.Compare(attrs2))

Output:

aci.AttributeTypes instances match: true

This example demonstrates why two seemingly identical instances, though created by separate functions, fail to evaluate as equal when multi-valued. The reason for this is due to the nature of the String method behavior for each of the instances. Use of the TAs package level function guarantees a delimitation scheme using the symbolic OR (||) symbol, while use of the UAs package level function uses comma-delimitation.

attrs1 := TAs(`cn`, `givenName`, `sn`, `objectClass`, `l`) // <x> || <x> || ...
attrs2 := UAs(`cn`, `givenName`, `sn`, `objectClass`, `l`) // x,x,x ...

fmt.Printf("%T instances match: %t", attrs1, attrs1.Compare(attrs2))

Output:

aci.AttributeTypes instances match: false

This example demonstrates the contrary condition to that demonstrated in the AttributeTypes CompareMultiValueFalse example. Because the two instances to be evaluated are single-valued, no delimiter scheme comes into play. As such, the two instances produce identical String output.

attrs1 := TAs(`cn`)
attrs2 := UAs(`cn`)

fmt.Printf("%T instances match: %t", attrs1, attrs1.Compare(attrs2))

Output:

aci.AttributeTypes instances match: true

attrs := TAs(
	`cn`,
	AT(`givenName`),
	`sn`,
	`objectClass`,
	AT(`l`),
)

fmt.Printf("Contains 'l': %t", attrs.Contains(`l`))

Output:

Contains 'l': true

attrs := TAs(
	`cn`,
	AT(`givenName`),
	`sn`,
	`objectClass`,
	AT(`l`),
)

fmt.Printf("%s", attrs.Eq())

Output:

( targetattr = "cn || givenName || sn || objectClass || l" )

This example demonstrates how to create a TargetAttr TargetRule Equality Condition using a list of AttributeType instances.

attrs := TAs().Push(
	AT(`cn`),
	AT(`sn`),
	AT(`givenName`),
)
fmt.Printf("%s", attrs.Eq())

Output:

( targetattr = "cn || sn || givenName" )

attrs := TAs(
	`l`,
	`cn`,
	`sn`,
	`givenName`,
	`objectClass`,
)

attr := attrs.F()(`homeDirectory`) // We've just executed 'AT' function without having to find it.
fmt.Printf("attr is %T", attr)

Output:

attr is aci.AttributeType

attrs := TAs(
	`cn`,
	AT(`givenName`),
	`sn`,
	`objectClass`,
	AT(`l`),
)

fmt.Printf("%s", attrs.Index(2))

Output:

sn

fmt.Printf("Empty stack: %t", TAs(`cn`, `sn`, `uid`).IsZero())

Output:

Empty stack: false

attrs := TAs(
	`l`,
	`cn`,
	`sn`,
	`givenName`,
	`objectClass`,
)

fmt.Printf("%s", attrs.Keyword())

Output:

targetattr

This example demonstrates the incompatibility with an AttributeTypes stack intended for use within an LDAPURI instance. Because this incarnation of AttributeTypes has no direct application within a BindRule or a TargetRule (rather it resides WITHIN another type eligible for such use), the Keyword cannot be inferred and returns a nil instance. This is expected behavior.

attrs := UAs(
	`l`,
	`cn`,
	`sn`,
	`givenName`,
	`objectClass`,
)

fmt.Printf("%s", attrs.Keyword())

Output:

targetfilter

attrs := TAs(
	`l`,
	`cn`,
	`sn`,
	`givenName`,
	`objectClass`,
)

fmt.Printf("%s", attrs.Kind())

Output:

targetattr

attrs := UAs(
	`l`,
	`cn`,
	`sn`,
	`givenName`,
	`objectClass`,
)

fmt.Printf("%s", attrs.Kind())

Output:

<uri_search_attributes>

var attrs AttributeTypes
fmt.Printf("%s", attrs.Kind())

Output:

<uninitialized>

fmt.Printf("%d attributeTypes", TAs(`cn`, `sn`, `uid`).Len())

Output:

3 attributeTypes

fmt.Printf("%s", TAs(AT(`aci`)).Ne())

Output:

( targetattr != "aci" )

This example demonstrates the removal of a single slice element from an AttributeTypes instance in LIFO fashion using its Pop method.

attrs := TAs(
	`cn`,
	AT(`givenName`),
	`sn`,
	`objectClass`,
	`l`,
)
popped := attrs.Pop()

fmt.Printf("%s", popped)

Output:

l

This example demonstrates the addition of new slice elements to an AttributeTypes instance using its Push method.

attrs := TAs(
	`cn`,
	AT(`givenName`),
	`sn`,
	`objectClass`,
)
attrs.Push(`l`)

fmt.Printf("%s", attrs)

Output:

cn || givenName || sn || objectClass || l

This example demonstrates the string representation of the receiver instance using its String method.

attrs := TAs(
	`cn`,
	AT(`givenName`),
	`sn`,
	`objectClass`,
)

fmt.Printf("%s", attrs)

Output:

cn || givenName || sn || objectClass

This example demonstrates the use of the receiver's TRM method in order to determine available ComparisonOperator-related methods available in this context.

attrs := TAs(
	`cn`,
	AT(`givenName`),
	`sn`,
	`objectClass`,
)

fmt.Printf("%d available comparison operator methods", attrs.TRM().Len())

Output:

2 available comparison operator methods

This example demonstrates the useless nature of the receiver's TRM method in situations where the receiver is intended for use within an LDAPURI instance, rather than as a rule condition unto itself. As a result, a bogus TargetRuleMethods instance will be returned if the receiver was created through any means *OTHER THAN* by execution of the TAs package level function.

attrs := UAs(
	`cn`,
	AT(`givenName`),
	`sn`,
	`objectClass`,
)

fmt.Printf("%d available comparison operator methods", attrs.TRM().Len())

Output:

0 available comparison operator methods

fmt.Printf("Empty stack: %t", TAs(`cn`, `sn`, `uid`).Valid() == nil)

Output:

Empty stack: true

This example demonstrates a SHA-1 hash comparison between the receiver and a test value. Note that the SHA-1 comparison is driven by the type instance's stringer output for simplicity in this package.

var (
	// granted, password values aren't an ACIv3 thing in
	// this context, but its still a fair example ...
	myPassword    AttributeValue = AV(`ALAA¢<ý²áßNß%a.)_ÿ3÷`)
	notMyPassword AttributeValue = AV(`ALAA¢<ýªáßNß%a.)_ÿ3÷`)
)

fmt.Printf("These passwords match: %t", myPassword.Compare(notMyPassword))

Output:

These passwords match: false

attr := AT(`homeDirectory`)
value := AV(`/home/jesse`)

fmt.Printf("My %s is '%s'", attr, value)

Output:

My homeDirectory is '/home/jesse'

meths := Anonymous.BRM()
fmt.Printf("%d available aci.BindRuleMethod instances", meths.Len())

Output:

2 available aci.BindRuleMethod instances

This example demonstrates the SHA-1 hash comparison between two (2) AuthenticationMethod instances using the Compare method.

fmt.Printf("%t", Anonymous.Compare(EXTERNAL))

Output:

false

fmt.Printf("%s", SASL.Eq())

Output:

authmethod = "SASL"

fmt.Printf("%s", Anonymous.Ne())

Output:

authmethod != "NONE"

fmt.Printf("%s", EXTERNAL)

Output:

SASL EXTERNAL

var dn BindDistinguishedName
fmt.Printf("%d available comparison operator methods", dn.BRM().Len())

Output:

2 available comparison operator methods

This example demonstrates the SHA-1 hash comparison between two (2) instances of BindDistinguishedName using the Compare method.

These seemingly different distinguished names actually evaluate as equal because the local LDAP prefix (ldap:///) is stripped off when the UDN (or similar) function is run. When the String method is executed for a distinguished name at a later point, said prefix is artificially imposed. Therefore in this scenario, the two values are in fact equal.

dn1 := UDN(`uid=jesse,ou=People,dc=example,dc=com`)
dn2 := UDN(`ldap:///uid=jesse,ou=People,dc=example,dc=com`)

fmt.Printf("Hashes are equal: %t", dn1.Compare(dn2))

Output:

Hashes are equal: true

var dn BindDistinguishedName = UDN(`uid=jesse,ou=People,dc=example,dc=com`)
fmt.Printf("%s", dn.Eq())

Output:

userdn = "ldap:///uid=jesse,ou=People,dc=example,dc=com"

var dn BindDistinguishedName
fmt.Printf("Zero: %t", dn.IsZero())

Output:

Zero: true

var dn BindDistinguishedName = UDN(`uid=jesse,ou=People,dc=example,dc=com`)
fmt.Printf("Keyword: %s", dn.Keyword())

Output:

Keyword: userdn

var dn BindDistinguishedName = UDN(`uid=jesse,ou=People,dc=example,dc=com`)
fmt.Printf("Kind: %s", dn.Kind())

Output:

Kind: bind

var dn BindDistinguishedName = UDN(`uid=jesse,ou=People,dc=example,dc=com`)
fmt.Printf("Length %d", dn.Len())

Output:

Length 1

var dn BindDistinguishedName = UDN(`uid=courtney,ou=People,dc=example,dc=com`)
fmt.Printf("%s", dn.Ne())

Output:

userdn != "ldap:///uid=courtney,ou=People,dc=example,dc=com"

var dn BindDistinguishedName
dn.Set(`cn=Role Profile,ou=Roles,dc=example,dc=com`, BindRDN)
fmt.Printf("%s", dn.Eq())

Output:

roledn = "ldap:///cn=Role Profile,ou=Roles,dc=example,dc=com"

var dn BindDistinguishedName = UDN(`uid=jesse,ou=People,dc=example,dc=com`)
fmt.Printf("%s", dn)

Output:

ldap:///uid=jesse,ou=People,dc=example,dc=com

var dn BindDistinguishedName
fmt.Printf("Valid: %t", dn.Valid() == nil)

Output:

Valid: false

var dn BindDistinguishedNames
fmt.Printf("%d available comparison operator methods", dn.BRM().Len())

Output:

2 available comparison operator methods

This example demonstrates the SHA-1 hash comparison between two (2) instances of BindDistinguishedNames using the Compare method.

The comparison evaluates as false because, while the contents match, their ordering does not.

adns := UDNs(`uid=jesse,ou=People,dc=example,dc=com`, `uid=courtney,ou=People,dc=example,dc=com`)
odns := UDNs(`uid=courtney,ou=People,dc=example,dc=com`, `uid=jesse,ou=People,dc=example,dc=com`)

fmt.Printf("Hashes are equal: %t", odns.Compare(adns))

Output:

Hashes are equal: false

dn := GDNs(
	`cn=Executives,ou=Groups,dc=example,dc=com`,
	`cn=Executive Assistants,ou=Groups,dc=example,dc=com`,
)

execs := `cn=Executives,ou=Groups,dc=example,dc=com`

fmt.Printf("Found: %t", dn.Contains(execs))

Output:

Found: true

var dn BindDistinguishedNames = UDNs(`uid=jesse,ou=People,dc=example,dc=com`)
fmt.Printf("%s", dn.Eq())

Output:

userdn = "ldap:///uid=jesse,ou=People,dc=example,dc=com"

var odns BindDistinguishedNames = UDNs()
funk := odns.F()
odns.Push(funk(`uid=jesse,ou=People,dc=example,dc=com`))

fmt.Printf("%s", odns)

Output:

ldap:///uid=jesse,ou=People,dc=example,dc=com

var dn BindDistinguishedNames
fmt.Printf("%s", dn.ID())

Output:

bind

This example demonstrates the call of a select slice member from the receiver using the Index method.

odns := UDNs(`uid=jesse,ou=People,dc=example,dc=com`, `uid=courtney,ou=People,dc=example,dc=com`)

fmt.Printf("%s", odns.Index(0))

Output:

ldap:///uid=jesse,ou=People,dc=example,dc=com

var odns BindDistinguishedNames
fmt.Printf("Zero: %t", odns.IsZero())

Output:

Zero: true

var dn BindDistinguishedNames = UDNs(`uid=jesse,ou=People,dc=example,dc=com`)
fmt.Printf("Keyword: %s", dn.Keyword())

Output:

Keyword: userdn

var odns BindDistinguishedNames = UDNs()
funk := odns.F()
odns.Push(funk(`uid=jesse,ou=People,dc=example,dc=com`))

fmt.Printf("Length: %d", odns.Len())

Output:

Length: 1

var dn BindDistinguishedNames = UDNs(`uid=jesse,ou=People,dc=example,dc=com`)
fmt.Printf("%s", dn.Ne())

Output:

userdn != "ldap:///uid=jesse,ou=People,dc=example,dc=com"

var odns BindDistinguishedNames = UDNs()
odns.Push(
	`uid=jesse,ou=People,dc=example,dc=com`,
	`uid=jimmy,ou=People,dc=example,dc=com`,
)

popped := odns.Pop()

fmt.Printf("%s", popped)

Output:

ldap:///uid=jimmy,ou=People,dc=example,dc=com

var odns BindDistinguishedNames = UDNs()
odns.Push(
	`uid=jesse,ou=People,dc=example,dc=com`,
	`uid=jimmy,ou=People,dc=example,dc=com`,
)

fmt.Printf("Length: %d", odns.Len())

Output:

Length: 2

var odns BindDistinguishedNames = UDNs()
odns.Push(
	`uid=jesse,ou=People,dc=example,dc=com`,
	`uid=jimmy,ou=People,dc=example,dc=com`,
)

fmt.Printf("%s", odns)

Output:

ldap:///uid=jesse,ou=People,dc=example,dc=com || ldap:///uid=jimmy,ou=People,dc=example,dc=com

var odns BindDistinguishedNames
fmt.Printf("Valid: %t", odns.Valid() == nil)

Output:

Valid: false

fmt.Printf("%s", BindUDN.Kind())

Output:

bind

fmt.Printf("%s", BindUDN)

Output:

userdn

fmt.Printf("%s", SSF(71).Eq().Category())

Output:

ssf

ssf1 := SSF(128).Eq()
ssf2 := SSF(127).Eq()
fmt.Printf("Equal: %t", ssf1.Compare(ssf2))

Output:

Equal: false

dn := `uid=jesse,ou=Contractors,ou=People,dc=example,dc=com`
fmt.Printf("%s", UDN(dn).Eq().Expression())

Output:

ldap:///uid=jesse,ou=Contractors,ou=People,dc=example,dc=com

fmt.Printf("%s", IP(`192.168.`).Ne().ID())

Output:

bind

var br BindRule
br.Init() // required when assembly through "piecemeal"

// ... later in your code ...

br.SetKeyword(BindUDN) // set keyword ...
br.SetOperator(Ne)     // ... so operator can be evaluated
fmt.Printf("Operator: %s", br.Operator().Description())

Output:

Operator: Not Equal To

This example demonstrates the useless execution of the IsNesting method, as its primary function does not apply to instances of BindRule, only BindRules.

As such, the execution of this method shall always return false.

var br BindRule
if err := br.Parse(`(timeofday>="0415")`); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}
fmt.Printf("%T.IsNesting: %t", br, br.IsNesting())

Output:

aci.BindRule.IsNesting: false

var br BindRule
if err := br.Parse(`(timeofday>="0415")`); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}
fmt.Printf("%T.IsParen: %t", br, br.IsParen())

Output:

aci.BindRule.IsParen: true

var tr BindRule
fmt.Printf("Zero: %t", tr.IsZero())

Output:

Zero: true

fmt.Printf("%s", SSF(0).Ne().Keyword())

Output:

ssf

var tr BindRule
fmt.Printf("%s", tr.Kind())

Output:

condition

This example demonstrates the (mostly) useless execution of the Len method, as singular BindRule instances are generally not judged in terms of length, whether value-based or some other abstraction.

As such, the execution of this method shall always return one (1) when executed on a non-nil instance, and zero (0) otherwise.

var br BindRule
if err := br.Parse(`(timeofday>="0415")`); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}
fmt.Printf("%T.Len: %d", br, br.Len())

Output:

aci.BindRule.Len: 1

var br BindRule
if err := br.Parse(`(timeofday>="0415")`); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}

fmt.Printf("%s", br.NoPadding(false))

Output:

( timeofday >= "0415" )

var br BindRule
br.Init() // required when assembly through "piecemeal"

// ... later in your code ...

br.SetKeyword(BindUDN) // set keyword ...
br.SetOperator(Ne)     // ... so operator can be evaluated
fmt.Printf("Operator: %s", br.Operator().Description())

Output:

Operator: Not Equal To

var br BindRule
if err := br.Parse(`(timeofday>="0415")`); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}

// Here we'll turn off parenthetical encaps
// and then verify it was turned off in one
// fmt.Printf call.

fmt.Printf("%T.IsParen: %t", br.Paren(false), br.IsParen())

Output:

aci.BindRule.IsParen: false

raw := `ssf >= "128"`
var br BindRule
if err := br.Parse(raw); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}

br.NoPadding(true)
br.Paren(true)

fmt.Printf("%s", br)

Output:

(ssf>="128")

var br BindRule
br.Init() // required when assembly through "piecemeal"

// ... later in your code ...

br.SetExpression(UDN(`uid=jesse,ou=People,dc=example,dc=com`))
fmt.Printf("Expression: %s", br.Expression().(BindDistinguishedName))

Output:

Expression: ldap:///uid=jesse,ou=People,dc=example,dc=com

var br BindRule
br.Init() // required when assembly through "piecemeal"

// ... later in your code ...

br.SetKeyword(BindGDN) // set keyword ...
fmt.Printf("Keyword: %s", br.Keyword())

Output:

Keyword: groupdn

var br BindRule
br.Init() // required when assembly through "piecemeal"

// ... later in your code ...

br.SetKeyword(BindUDN) // set keyword ...
br.SetOperator(Ne)     // ... so operator can be evaluated
fmt.Printf("Operator: %s", br.Operator().Description())

Output:

Operator: Not Equal To

var tgt BindRule
tgt.SetKeyword(BindUDN)

tgt.Init()

tgt.SetKeyword(BindUDN)
tgt.SetOperator(`!=`)
tgt.SetOperator(2)
tgt.SetOperator(54738372)
tgt.SetOperator(Ne)
tgt.SetExpression(UDNs(
	UDN(`ldap:///uid=jesse,ou=People,dc=example,dc=com`),
	UDN(`ldap:///uid=courtney,ou=People,dc=example,dc=com`),
	UDN(`ldap:///uid=jimmy,ou=People,dc=example,dc=com`),
))

tgt.Paren() // optional

tgt.SetQuoteStyle(0)
style1 := tgt.String()

tgt.SetQuoteStyle(1)
style2 := tgt.String()

fmt.Printf("\n0: %s\n1: %s", style1, style2)

Output:

0: ( userdn != "ldap:///uid=jesse,ou=People,dc=example,dc=com" || "ldap:///uid=courtney,ou=People,dc=example,dc=com" || "ldap:///uid=jimmy,ou=People,dc=example,dc=com" )
1: ( userdn != "ldap:///uid=jesse,ou=People,dc=example,dc=com || ldap:///uid=courtney,ou=People,dc=example,dc=com || ldap:///uid=jimmy,ou=People,dc=example,dc=com" )

var br BindRule
if err := br.Parse(`(timeofday>="0415")`); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}

fmt.Printf("%s", br)

Output:

( timeofday >= "0415" )

This example demonstrates the useless nature of the Traverse method for a receiver that is an instance of BindRule. As BindRule is logically "singular", there is no structure in which a traversal would be possible. The Traverse method only exists to satisfy Go's interface signature requirements as they pertain to the BindContext type, and this test exists only to maintain code coverage and to convey this message.

Execution of this method simply returns the receiver.

br := SSF(71).Eq()
fmt.Printf("%T", br.Traverse(1, 2, 3, 4, 5))

Output:

aci.BindRule

var tr BindRule
fmt.Printf("Valid: %t", tr.Valid() == nil)

Output:

Valid: false

ssf := SSF(256)
brm := ssf.BRM()

for i := 0; i < brm.Len(); i++ {
	// IMPORTANT: Do not call index 0. Either adjust your
	// loop variable (i) to begin at 1, and terminate at
	// brm.Len()+1 --OR-- simply +1 the index call as we
	// are doing here (seems easier). The reason for this
	// is because there is no valid ComparisonOperator
	// with an underlying uint8 value of zero (0). See
	// the ComparisonOperator constants for details.
	idx := i + 1
	cop, meth := brm.Index(idx)

	// execute method to create the bindrule, while
	// also enabling the (optional) parenthetical bit
	rule := meth().Paren()

	// grab the raw string output
	fmt.Printf("[%d] %T instance [%s] execution returned %T: %s\n", idx, meth, cop.Context(), rule, rule)
}

Output:

[1] aci.BindRuleMethod instance [Eq] execution returned aci.BindRule: ( ssf = "256" )
[2] aci.BindRuleMethod instance [Ne] execution returned aci.BindRule: ( ssf != "256" )
[3] aci.BindRuleMethod instance [Lt] execution returned aci.BindRule: ( ssf < "256" )
[4] aci.BindRuleMethod instance [Gt] execution returned aci.BindRule: ( ssf > "256" )
[5] aci.BindRuleMethod instance [Le] execution returned aci.BindRule: ( ssf <= "256" )
[6] aci.BindRuleMethod instance [Ge] execution returned aci.BindRule: ( ssf >= "256" )

ssf := SSF(256)
brm := ssf.BRM()

// Here, we demonstrate calling a particular BindRuleMethod
// not by its numerical index, but rather by its actual
// "symbolic" operator representation. Keep in mind these
// options for text-based searches:
//
// - symbols (e.g.: '=', '>') are available via ComparisonOperator.String()
// - func names (e.g.: 'Eq', 'Gt') are available via ComparisonOperator.Context()
// - descriptions (e.g.: 'Not Equal To', 'Less Than') are available via ComparisonOperator.Description()
//
// As such, feel free to replace these list items with one of the above methods,
// but keep in mind that text based searches are more resource intensive than as
// compared to direct ComparisonOperator numeric calls. If you have performance
// concerns, avoid this text based procedure.
for i, term := range []string{
	`=`,
	`!=`,
	`<`,
	`>`,
	`<=`,
	`>=`,
} {
	// IMPORTANT: Do not call index 0. Either adjust your
	// loop variable (i) to begin at 1, and terminate at
	// brm.Len()+1 --OR-- simply +1 the index call as we
	// are doing here (seems easier). The reason for this
	// is because there is no valid ComparisonOperator
	// with an underlying uint8 value of zero (0). See
	// the ComparisonOperator constants for details.
	cop, meth := brm.Index(term)

	// execute method to create the bindrule, while
	// also enabling the (optional) parenthetical bit
	rule := meth().Paren()

	// grab the raw string output
	fmt.Printf("[%d] %T instance [%s] execution returned %T: %s\n", i+1, meth, cop.Context(), rule, rule)
}

Output:

[1] aci.BindRuleMethod instance [Eq] execution returned aci.BindRule: ( ssf = "256" )
[2] aci.BindRuleMethod instance [Ne] execution returned aci.BindRule: ( ssf != "256" )
[3] aci.BindRuleMethod instance [Lt] execution returned aci.BindRule: ( ssf < "256" )
[4] aci.BindRuleMethod instance [Gt] execution returned aci.BindRule: ( ssf > "256" )
[5] aci.BindRuleMethod instance [Le] execution returned aci.BindRule: ( ssf <= "256" )
[6] aci.BindRuleMethod instance [Ge] execution returned aci.BindRule: ( ssf >= "256" )

var brm BindRuleMethods
fmt.Printf("Zero: %t", brm.IsZero())

Output:

Zero: true

// Note: we need not populate the value to get a
// BRM list, but the methods in that list won't
// actually work until the instance (ssf) is in
// an acceptable state. Since all we're doing
// here is checking the length, a receiver that
// is nil/zero is totally fine.
var ssf SecurityStrengthFactor // not init'd
total := ssf.BRM().Len()

fmt.Printf("There are %d available aci.BindRuleMethod instances for creating %T BindRules", total, ssf)

Output:

There are 6 available aci.BindRuleMethod instances for creating aci.SecurityStrengthFactor BindRules

var brm BindRuleMethods
fmt.Printf("Error: %v", brm.Valid())

Output:

Error: aci.BindRuleMethods instance is nil

fmt.Printf("%s", And(SSF(71).Eq()).Category())

Output:

and

tf1 := Timeframe(ToD(`0130`), ToD(`1605`))
tf2 := Timeframe(ToD(`1215`), ToD(`1605`))

fmt.Printf("Equal: %t", tf1.Compare(tf2))

Output:

Equal: false

This example demonstrates the toggling of Boolean WORD operator case-folding of a BindRules instance.

strong := And(SSF(128).Ge(), EXTERNAL.Eq())
strong.Fold() // we want `AND` to be `and`

fmt.Printf("%s", strong)

Output:

ssf >= "128" and authmethod = "SASL EXTERNAL"

var brs BindRules
fmt.Printf("%s", brs.ID())

Output:

bind

This example demonstrates the calling of a specific slice member by its numerical index using the BindRules.Index method.

brs := And(
	Timeframe(
		ToD(`0900`),
		ToD(`1830`),
	),
	Weekdays(Eq),
)

fmt.Printf("%s", brs.Index(0))

Output:

timeofday >= "0900" AND timeofday < "1830"

This example demonstrates the interrogation of a BindRules instance to determine whether any of its immediate slice members are other stack elements, thereby indicating that a "nesting condition" is in effect.

brs := And(
	Timeframe(
		ToD(`0900`),
		ToD(`1830`),
	),
	Weekdays(Eq),
)

fmt.Printf("Contains nesting elements: %t", brs.IsNesting())

Output:

Contains nesting elements: true

// Use the convenient timeframe prefabber to
// create a BindRules instance, for which we
// engage parentheticals, all in one shot.
tf := Timeframe(ToD(`0700`), ToD(`1800`)).Paren()

fmt.Printf("%T.IsParen: %t", tf, tf.IsParen())

Output:

aci.BindRules.IsParen: true

var brs BindRules
fmt.Printf("Zero: %t", brs.IsZero())

Output:

Zero: true

This example demonstrates the use of the useless Keyword method that returns a bogus keyword in string representation. Keywords are only directly applicable to BindRule instances.

tf := Timeframe(
	ToD(`0900`),
	ToD(`1830`),
)

fmt.Printf("%s", tf.Keyword())

Output:

<invalid_bind_keyword>

This example demonstrates the use of the Kind method to reveal the underlying type of the receiver. This is for use during the handling of a combination of BindRules and BindRule instances under the BindContext interface context.

brs := And(
	Timeframe(
		ToD(`0900`),
		ToD(`1830`),
	),
	Weekdays(Eq),
)

fmt.Printf("%s", brs.Kind())

Output:

stack

This example demonstrates the interrogation of a BindRules instance to determine its integer length using its Len method. The return value describes the number of slice elements present within the instance.

brs := And(
	Timeframe(
		ToD(`0900`),
		ToD(`1830`),
	),
	Weekdays(Eq),
)

fmt.Printf("Contains %d elements", brs.Len())

Output:

Contains 2 elements

This example demonstrates the use of the NoPadding method to remove the outer padding of a BindRules instance. Note that parentheticals are enabled for visual aid.

brs := And(
	Timeframe(
		ToD(`0900`),
		ToD(`1830`),
	),
	Weekdays(Eq),
)

brs.Paren().NoPadding()

fmt.Printf("%s", brs)

Output:

(timeofday >= "0900" AND timeofday < "1830" AND dayofweek = "Mon,Tues,Wed,Thur,Fri")

This example demonstrates the use of the Paren method to enable the parenthetical setting for the receiver instance.

brs := And(
	Timeframe(
		ToD(`0900`),
		ToD(`1830`),
	),
	Weekdays(Eq),
)

brs.Paren()

fmt.Printf("%s", brs)

Output:

( timeofday >= "0900" AND timeofday < "1830" AND dayofweek = "Mon,Tues,Wed,Thur,Fri" )

raw := `( ssf >= "128" AND ( authmethod = "SASL" OR authmethod = "SSL" ) )`
var brs BindRules
if err := brs.Parse(raw); err != nil {
	fmt.Println(err) // always check your parser errors
	return
}

fmt.Printf("%s", brs.Traverse(0, 1, 0))

Output:

authmethod = "SASL"

raw := `(
                        (
                                ( userdn = "ldap:///anyone" ) AND
                                ( ssf >= "71" )

                        ) AND NOT (
                                dayofweek = "Wed" OR
                                dayofweek = "Fri"
                        )
        )`

br, err := ParseBindRules(raw)
if err != nil {
	fmt.Println(err) // always check your parser errors
	return
}

called := br.Traverse(0, 0, 0)
fmt.Printf("%s", called)

Output:

( userdn = "ldap:///anyone" )

This example demonstrates the removal of a single slice within a BindRules instance in LIFO fashion using its Pop method.

// create a single BindRules instance
// with two (2) slices ...
brs := And(
	Timeframe(
		ToD(`0900`), // slice #0
		ToD(`1830`), // slice #1
	),
	Weekdays(Eq),
)

// Remove (by Pop) the Weekdays slice (slice #1)
popped := brs.Pop()

fmt.Printf("%s", popped)

Output:

dayofweek = "Mon,Tues,Wed,Thur,Fri"

This example demonstrates the addition of new slice elements to a BindRules instance using its Push method.

// create a single BindRules instance
// with only one (1) slice (Timeframe
// BindRule) ...
brs := And(
	Timeframe(
		ToD(`0900`),
		ToD(`1830`),
	),
)

// Add a Weekdays BindRule prefab
brs.Push(Weekdays(Eq))

fmt.Printf("%s", brs)

Output:

timeofday >= "0900" AND timeofday < "1830" AND dayofweek = "Mon,Tues,Wed,Thur,Fri"

This example demonstrates an attempt to modify a BindRules stack instance while its ReadOnly bit is enabled.

strong := And(
	SSF(128).Ge(),  // slice #0
	DIGESTMD5.Eq(), // slice #1
)

strong.ReadOnly()

// Try to replace awful Digest-MD5 with
// the SASL/EXTERNAL mechanism.
strong.Replace(EXTERNAL.Eq(), 1)

fmt.Printf("%s", strong)

Output:

ssf >= "128" AND authmethod = "SASL DIGEST-MD5"

This example demonstrates the selective replacement of a specific BindRules stack slice.

strong := And(
	SSF(128).Ge(),  // slice #0
	DIGESTMD5.Eq(), // slice #1
)

// Replace awful Digest-MD5 with the
// SASL/EXTERNAL mechanism.
strong.Replace(EXTERNAL.Eq(), 1) // <x> replace slice #1

fmt.Printf("%s", strong)

Output:

ssf >= "128" AND authmethod = "SASL EXTERNAL"

strong := And(SSF(128).Ge(), EXTERNAL.Eq())

fmt.Printf("%s", strong)

Output:

ssf >= "128" AND authmethod = "SASL EXTERNAL"

This example demonstrates the traversal of a BindRules structure to obtain a specific nested element, in this case the 'ssf >= "128"' expression.

// And() is the variable for the outermost stack, don't count it as an index.
// Rather, begin counting its children instead.
rules := And(
	GDN(`cn=X.500 Administrators,ou=Groups,dc=example,dc=com`).Eq().Paren(),
	Timeframe(ToD(`1730`), ToD(`2330`)).Paren(),

	// Enter the Or stack by descending within the third element (AND slice #2)
	Or(
		UAT(`manager`, `LDAPURL`).Eq().Paren(),
		GAT(`owner`, SELFDN).Eq().Paren(),
		URI(UDN(`ou=People,dc=example,dc=com`), Subtree).Eq().Paren(),
		// OR slice #3. This is ILLOGICAL because
		// there's no benefit to placing an AND in
		// this rule, as it does not produce what
		// would be viewed as a "sensible" statement
		// of evaluation.
		And(
			// Inner AND slice #0
			SSF(128).Ge(),
		),
	),
)

ssf := rules.Traverse(2, 3, 0)
fmt.Printf("%s", ssf)

Output:

ssf >= "128"

This is an identical scenario to the above Traverse example, except in this scenario we will be writing to the slice returned.

// And() is the variable for the outermost stack, don't count it as an index.
// Rather, begin counting its children instead.
rules := And(
	GDN(`cn=X.500 Administrators,ou=Groups,dc=example,dc=com`).Eq().Paren(),
	Timeframe(ToD(`1730`), ToD(`2330`)).Paren(),

	// Enter the Or stack by descending within the third element (AND slice #2)
	Or(
		UAT(`manager`, `LDAPURL`).Eq().Paren(),
		GAT(`owner`, SELFDN).Eq().Paren(),
		URI(UDN(`ou=People,dc=example,dc=com`), Subtree).Eq().Paren(),
		// OR slice #3
		And(
			// Inner AND slice #0
			SSF(128).Ge(),
		),
	),
)

// Call the specific stack/slice we want. Remember,
// Traverse returns a BindContext interface, which
// will be either BindRule OR BindRules. In this
// demonstration, we know what it is, thus we need
// not perform type switching in a case statement.
raw := rules.Traverse(2, 3, 0)
asserted, ok := raw.(BindRule)
if !ok {
	fmt.Printf("Failed to assert %T", asserted)
	return
}

// Because go-stackage is so heavily pointer-based,
// we need not worry about "writing the updated SSF
// value back to the stack". Just make the changes
// to the condition itself, and be done with it.
asserted.SetExpression(SSF(164)) // set to 164 because I'm so arbitrary

// Do the stack walk again to see if the pointer updated ...
fmt.Printf("%s", rules.Traverse(2, 3, 0))

Output:

ssf >= "164"

var brs BindRules
fmt.Printf("Valid: %t", brs.Valid() == nil)

Output:

Valid: false