regexnew

Documentation

Index

• Variables
• func Create(regularExpressionPattern string) (*regexp.Regexp, error)
• func CreateApplicableLock(regularExpressionPattern string) (regEx *regexp.Regexp, err error, isApplicable bool)
• func CreateLock(regularExpressionPattern string) (*regexp.Regexp, error)
• func CreateLockIf(isLock bool, regularExpressionSyntax string) (*regexp.Regexp, error)
• func CreateMust(regularExpressionSyntax string) *regexp.Regexp
• func CreateMustLockIf(isLock bool, regularExpressionSyntax string) *regexp.Regexp
• func IsMatchFailed(regex, comparing string) bool
• func IsMatchLock(regex, comparing string) bool
• func MatchError(regex, comparing string) error
• func MatchErrorLock(regex, comparing string) error
• func MatchUsingCustomizeErrorFuncLock(regexPattern, comparing string, matchFunc RegexValidationFunc, ...) error
• func MatchUsingFuncErrorLock(regexPattern, comparing string, matchFunc RegexValidationFunc) error
• func NewMustLock(regularExpressionSyntax string) *regexp.Regexp
• type CustomizeErr
• type LazyRegex
  • func (it *LazyRegex) Compile() (regex *regexp.Regexp, err error)
  • func (it *LazyRegex) CompileMust() (regex *regexp.Regexp)
  • func (it *LazyRegex) CompiledError() error
  • func (it *LazyRegex) Error() error
  • func (it *LazyRegex) FirstMatchLine(content string) (firstMatch string, isInvalidMatch bool)
  • func (it *LazyRegex) FullString() (detail string)
  • func (it *LazyRegex) HasAnyIssues() bool
  • func (it *LazyRegex) HasError() bool
  • func (it *LazyRegex) IsApplicable() bool
  • func (it *LazyRegex) IsCompiled() bool
  • func (it *LazyRegex) IsDefined() bool
  • func (it *LazyRegex) IsFailedMatch(comparing string) bool
  • func (it *LazyRegex) IsFailedMatchBytes(comparingBytes []byte) bool
  • func (it *LazyRegex) IsInvalid() bool
  • func (it *LazyRegex) IsMatch(comparing string) bool
  • func (it *LazyRegex) IsMatchBytes(comparingBytes []byte) bool
  • func (it *LazyRegex) IsNull() bool
  • func (it *LazyRegex) IsUndefined() bool
  • func (it *LazyRegex) MatchError(matchingPattern string) error
  • func (it *LazyRegex) MatchUsingFuncError(comparing string, matchFunc RegexValidationFunc) error
  • func (it *LazyRegex) MustBeSafe()
  • func (it *LazyRegex) OnRequiredCompiled() error
  • func (it *LazyRegex) OnRequiredCompiledMust()
  • func (it *LazyRegex) Pattern() (pattern string)
  • func (it *LazyRegex) String() (pattern string)
• type RegexValidationFunc

Variables

var (
	WhitespaceFinderRegex             = New.Lazy(regconsts.AllWhitespaces)
	HashCommentWithSpaceOptionalRegex = New.Lazy(regconsts.HashCommentWithSpaceOptional)
	WhitespaceOrPipeFinderRegex       = New.Lazy(regconsts.AllWhitespacesOrPipe)
	DollarIdentifierRegex             = New.Lazy(regconsts.EachWordsWithDollarSymbolDefinition)
	PercentIdentifierRegex            = New.Lazy(regconsts.EachWordsWithinPercentSymbolDefinition)
	PrettyNameRegex                   = New.Lazy(regconsts.PrettyName)
	ExactIdFieldMatchingRegex         = New.Lazy(regconsts.ExactIdFieldMatching)
	ExactVersionIdFieldMatchingRegex  = New.Lazy(regconsts.ExactVersionIdFieldMatching)
	UbuntuNameCheckerRegex            = New.Lazy(regconsts.UbuntuNameChecker)
	CentOsNameCheckerRegex            = New.Lazy(regconsts.CentOsNameChecker)
	RedHatNameCheckerRegex            = New.Lazy(regconsts.RedHatNameChecker)
	FirstNumberAnyWhereCheckerRegex   = New.Lazy(regconsts.FirstNumberAnyWhere)
	WindowsVersionNumberCheckerRegex  = FirstNumberAnyWhereCheckerRegex
)

var (
	New = newCreator{}
)

Functions

func Create

func Create(regularExpressionPattern string) (*regexp.Regexp, error)

Create creates regex if not already exist in dictionary.

if any error then doesn't save to map and returns the error

func CreateApplicableLock

func CreateApplicableLock(regularExpressionPattern string) (
	regEx *regexp.Regexp,
	err error,
	isApplicable bool,
)

CreateApplicableLock

calls Create with mutex lock and unlock.

func CreateLock

func CreateLock(regularExpressionPattern string) (*regexp.Regexp, error)

CreateLock calls Create with mutex lock and unlock.

func CreateLockIf

func CreateLockIf(isLock bool, regularExpressionSyntax string) (*regexp.Regexp, error)

CreateLockIf calls Create with mutex lock and unlock if true.

func CreateMust

func CreateMust(regularExpressionSyntax string) *regexp.Regexp

CreateMust creates regex if not already exist in dictionary.

if any error then panics

func CreateMustLockIf

func CreateMustLockIf(
	isLock bool,
	regularExpressionSyntax string,
) *regexp.Regexp

func IsMatchFailed

func IsMatchFailed(regex, comparing string) bool

IsMatchFailed creates new regex using lock and then calls match if doesn't match returns true

func IsMatchLock

func IsMatchLock(regex, comparing string) bool

IsMatchLock creates new regex using lock and then calls match if doesn't match or invalid regex then returns false.

func MatchError

func MatchError(regex, comparing string) error

MatchError

creates new regex using without lock (use in vars) and then calls match. On condition mismatch returns error or else nil

func MatchErrorLock

func MatchErrorLock(regex, comparing string) error

MatchErrorLock

creates new regex using lock and then calls match. On condition mismatch returns error or else nil

func MatchUsingCustomizeErrorFuncLock

func MatchUsingCustomizeErrorFuncLock(
	regexPattern, comparing string,
	matchFunc RegexValidationFunc,
	customizeErrFunc CustomizeErr,
) error

MatchUsingCustomizeErrorFuncLock

creates new regex using lock and then calls match. On condition mismatch returns error or else nil

func MatchUsingFuncErrorLock

func MatchUsingFuncErrorLock(
	regexPattern, comparing string,
	matchFunc RegexValidationFunc,
) error

MatchUsingFuncErrorLock

creates new regex using lock and then calls match. On condition mismatch returns error or else nil

func NewMustLock

func NewMustLock(regularExpressionSyntax string) *regexp.Regexp

Types

type CustomizeErr

type CustomizeErr func(
	regexPattern,
	matchLookingTerm string,
	err error,
	regexp *regexp.Regexp,
) error

type LazyRegex

type LazyRegex struct {
	// contains filtered or unexported fields
}

LazyRegex

lazy regex for future unwrapping or compiled but only once.

func (*LazyRegex) Compile

func (it *LazyRegex) Compile() (regex *regexp.Regexp, err error)

Compile

it is done through the locking mechanism

func (*LazyRegex) CompileMust

func (it *LazyRegex) CompileMust() (regex *regexp.Regexp)

func (*LazyRegex) CompiledError

func (it *LazyRegex) CompiledError() error

func (*LazyRegex) Error

func (it *LazyRegex) Error() error

func (*LazyRegex) FirstMatchLine

func (it *LazyRegex) FirstMatchLine(
	content string,
) (firstMatch string, isInvalidMatch bool)

func (*LazyRegex) FullString

func (it *LazyRegex) FullString() (detail string)

func (*LazyRegex) HasAnyIssues

func (it *LazyRegex) HasAnyIssues() bool

func (*LazyRegex) HasError

func (it *LazyRegex) HasError() bool

func (*LazyRegex) IsApplicable

func (it *LazyRegex) IsApplicable() bool

IsApplicable

it unwraps the regex and compiles so take memory for once.

func (*LazyRegex) IsCompiled

func (it *LazyRegex) IsCompiled() bool

func (*LazyRegex) IsDefined

func (it *LazyRegex) IsDefined() bool

func (*LazyRegex) IsFailedMatch

func (it *LazyRegex) IsFailedMatch(
	comparing string,
) bool

func (*LazyRegex) IsFailedMatchBytes

func (it *LazyRegex) IsFailedMatchBytes(
	comparingBytes []byte,
) bool

func (*LazyRegex) IsInvalid

func (it *LazyRegex) IsInvalid() bool

func (*LazyRegex) IsMatch

func (it *LazyRegex) IsMatch(
	comparing string,
) bool

func (*LazyRegex) IsMatchBytes

func (it *LazyRegex) IsMatchBytes(
	comparingBytes []byte,
) bool

func (*LazyRegex) IsNull

func (it *LazyRegex) IsNull() bool

func (*LazyRegex) IsUndefined

func (it *LazyRegex) IsUndefined() bool

func (*LazyRegex) MatchError

func (it *LazyRegex) MatchError(matchingPattern string) error

func (*LazyRegex) MatchUsingFuncError

func (it *LazyRegex) MatchUsingFuncError(
	comparing string,
	matchFunc RegexValidationFunc,
) error

MatchUsingFuncError

creates new regex using lock
and then calls match.
On condition mismatch returns error
or else nil

func (*LazyRegex) MustBeSafe

func (it *LazyRegex) MustBeSafe()

func (*LazyRegex) OnRequiredCompiled

func (it *LazyRegex) OnRequiredCompiled() error

func (*LazyRegex) OnRequiredCompiledMust

func (it *LazyRegex) OnRequiredCompiledMust()

func (*LazyRegex) Pattern

func (it *LazyRegex) Pattern() (pattern string)

func (*LazyRegex) String

func (it *LazyRegex) String() (pattern string)

type RegexValidationFunc

type RegexValidationFunc func(regex *regexp.Regexp, lookingTerm string) bool