parsers

Documentation

Overview

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Code generated by go generate; DO NOT EDIT.

Copyright 2019 HAProxy Technologies

Licensed 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.

Index

• Constants
• type ACL
  • func (p *ACL) Delete(index int) error
  • func (p *ACL) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *ACL) GetOne(index int) (common.ParserData, error)
  • func (p *ACL) GetParserName() string
  • func (p *ACL) Init()
  • func (p *ACL) Insert(data common.ParserData, index int) error
  • func (p *ACL) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *ACL) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *ACL) Result() ([]common.ReturnResultLine, error)
  • func (p *ACL) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *ACL) Set(data common.ParserData, index int) error
• type Balance
  • func (p *Balance) Delete(index int) error
  • func (p *Balance) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Balance) GetOne(index int) (common.ParserData, error)
  • func (p *Balance) GetParserName() string
  • func (p *Balance) Init()
  • func (p *Balance) Insert(data common.ParserData, index int) error
  • func (p *Balance) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Balance) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *Balance) Result() ([]common.ReturnResultLine, error)
  • func (p *Balance) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Balance) Set(data common.ParserData, index int) error
• type Bind
  • func (p *Bind) Delete(index int) error
  • func (p *Bind) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Bind) GetOne(index int) (common.ParserData, error)
  • func (p *Bind) GetParserName() string
  • func (p *Bind) Init()
  • func (p *Bind) Insert(data common.ParserData, index int) error
  • func (p *Bind) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Bind) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *Bind) Result() ([]common.ReturnResultLine, error)
  • func (p *Bind) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Bind) Set(data common.ParserData, index int) error
• type BindProcess
  • func (p *BindProcess) Delete(index int) error
  • func (p *BindProcess) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *BindProcess) GetOne(index int) (common.ParserData, error)
  • func (p *BindProcess) GetParserName() string
  • func (p *BindProcess) Init()
  • func (p *BindProcess) Insert(data common.ParserData, index int) error
  • func (p *BindProcess) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *BindProcess) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *BindProcess) Result() ([]common.ReturnResultLine, error)
  • func (p *BindProcess) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *BindProcess) Set(data common.ParserData, index int) error
• type CPUMap
  • func (p *CPUMap) Delete(index int) error
  • func (c *CPUMap) Equal(b *CPUMap) bool
  • func (p *CPUMap) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *CPUMap) GetOne(index int) (common.ParserData, error)
  • func (p *CPUMap) GetParserName() string
  • func (p *CPUMap) Init()
  • func (p *CPUMap) Insert(data common.ParserData, index int) error
  • func (p *CPUMap) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *CPUMap) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (c *CPUMap) Result() ([]common.ReturnResultLine, error)
  • func (p *CPUMap) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *CPUMap) Set(data common.ParserData, index int) error
• type ConfigSnippet
  • func (p *ConfigSnippet) Delete(index int) error
  • func (p *ConfigSnippet) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *ConfigSnippet) GetOne(index int) (common.ParserData, error)
  • func (p *ConfigSnippet) GetParserName() string
  • func (p *ConfigSnippet) Init()
  • func (p *ConfigSnippet) Insert(data common.ParserData, index int) error
  • func (p *ConfigSnippet) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *ConfigSnippet) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *ConfigSnippet) Result() ([]common.ReturnResultLine, error)
  • func (p *ConfigSnippet) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *ConfigSnippet) Set(data common.ParserData, index int) error
• type Cookie
  • func (p *Cookie) Delete(index int) error
  • func (p *Cookie) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Cookie) GetOne(index int) (common.ParserData, error)
  • func (p *Cookie) GetParserName() string
  • func (p *Cookie) Init()
  • func (p *Cookie) Insert(data common.ParserData, index int) error
  • func (p *Cookie) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Cookie) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *Cookie) Result() ([]common.ReturnResultLine, error)
  • func (p *Cookie) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Cookie) Set(data common.ParserData, index int) error
• type Daemon
  • func (p *Daemon) Delete(index int) error
  • func (p *Daemon) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Daemon) GetOne(index int) (common.ParserData, error)
  • func (p *Daemon) GetParserName() string
  • func (p *Daemon) Init()
  • func (p *Daemon) Insert(data common.ParserData, index int) error
  • func (d *Daemon) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Daemon) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (d *Daemon) Result() ([]common.ReturnResultLine, error)
  • func (p *Daemon) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Daemon) Set(data common.ParserData, index int) error
• type DefaultBackend
  • func (p *DefaultBackend) Delete(index int) error
  • func (p *DefaultBackend) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *DefaultBackend) GetOne(index int) (common.ParserData, error)
  • func (p *DefaultBackend) GetParserName() string
  • func (p *DefaultBackend) Init()
  • func (p *DefaultBackend) Insert(data common.ParserData, index int) error
  • func (s *DefaultBackend) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *DefaultBackend) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *DefaultBackend) Result() ([]common.ReturnResultLine, error)
  • func (p *DefaultBackend) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *DefaultBackend) Set(data common.ParserData, index int) error
• type DefaultServer
  • func (p *DefaultServer) Delete(index int) error
  • func (p *DefaultServer) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *DefaultServer) GetOne(index int) (common.ParserData, error)
  • func (p *DefaultServer) GetParserName() string
  • func (p *DefaultServer) Init()
  • func (p *DefaultServer) Insert(data common.ParserData, index int) error
  • func (p *DefaultServer) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *DefaultServer) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *DefaultServer) Result() ([]common.ReturnResultLine, error)
  • func (p *DefaultServer) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *DefaultServer) Set(data common.ParserData, index int) error
• type ErrorFile
  • func (p *ErrorFile) Delete(index int) error
  • func (p *ErrorFile) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *ErrorFile) GetOne(index int) (common.ParserData, error)
  • func (p *ErrorFile) GetParserName() string
  • func (l *ErrorFile) Init()
  • func (p *ErrorFile) Insert(data common.ParserData, index int) error
  • func (p *ErrorFile) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *ErrorFile) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *ErrorFile) Result() ([]common.ReturnResultLine, error)
  • func (p *ErrorFile) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *ErrorFile) Set(data common.ParserData, index int) error
• type ExternalCheck
  • func (p *ExternalCheck) Delete(index int) error
  • func (p *ExternalCheck) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *ExternalCheck) GetOne(index int) (common.ParserData, error)
  • func (p *ExternalCheck) GetParserName() string
  • func (p *ExternalCheck) Init()
  • func (p *ExternalCheck) Insert(data common.ParserData, index int) error
  • func (m *ExternalCheck) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *ExternalCheck) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (m *ExternalCheck) Result() ([]common.ReturnResultLine, error)
  • func (p *ExternalCheck) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *ExternalCheck) Set(data common.ParserData, index int) error
• type ExternalCheckCommand
  • func (p *ExternalCheckCommand) Delete(index int) error
  • func (p *ExternalCheckCommand) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *ExternalCheckCommand) GetOne(index int) (common.ParserData, error)
  • func (p *ExternalCheckCommand) GetParserName() string
  • func (p *ExternalCheckCommand) Init()
  • func (p *ExternalCheckCommand) Insert(data common.ParserData, index int) error
  • func (s *ExternalCheckCommand) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *ExternalCheckCommand) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *ExternalCheckCommand) Result() ([]common.ReturnResultLine, error)
  • func (p *ExternalCheckCommand) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *ExternalCheckCommand) Set(data common.ParserData, index int) error
• type ExternalCheckPath
  • func (p *ExternalCheckPath) Delete(index int) error
  • func (p *ExternalCheckPath) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *ExternalCheckPath) GetOne(index int) (common.ParserData, error)
  • func (p *ExternalCheckPath) GetParserName() string
  • func (p *ExternalCheckPath) Init()
  • func (p *ExternalCheckPath) Insert(data common.ParserData, index int) error
  • func (s *ExternalCheckPath) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *ExternalCheckPath) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *ExternalCheckPath) Result() ([]common.ReturnResultLine, error)
  • func (p *ExternalCheckPath) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *ExternalCheckPath) Set(data common.ParserData, index int) error
• type Group
  • func (p *Group) Delete(index int) error
  • func (p *Group) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Group) GetOne(index int) (common.ParserData, error)
  • func (p *Group) GetParserName() string
  • func (p *Group) Init()
  • func (p *Group) Insert(data common.ParserData, index int) error
  • func (p *Group) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Group) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *Group) Result() ([]common.ReturnResultLine, error)
  • func (p *Group) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Group) Set(data common.ParserData, index int) error
• type HTTPCheckV2
  • func (p *HTTPCheckV2) Delete(index int) error
  • func (p *HTTPCheckV2) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *HTTPCheckV2) GetOne(index int) (common.ParserData, error)
  • func (p *HTTPCheckV2) GetParserName() string
  • func (p *HTTPCheckV2) Init()
  • func (p *HTTPCheckV2) Insert(data common.ParserData, index int) error
  • func (p *HTTPCheckV2) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *HTTPCheckV2) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *HTTPCheckV2) Result() ([]common.ReturnResultLine, error)
  • func (p *HTTPCheckV2) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *HTTPCheckV2) Set(data common.ParserData, index int) error
• type HTTPReuse
  • func (p *HTTPReuse) Delete(index int) error
  • func (p *HTTPReuse) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *HTTPReuse) GetOne(index int) (common.ParserData, error)
  • func (p *HTTPReuse) GetParserName() string
  • func (p *HTTPReuse) Init()
  • func (p *HTTPReuse) Insert(data common.ParserData, index int) error
  • func (p *HTTPReuse) Parse(line string, parts, previousPats []string, comment string) (changeState string, err error)
  • func (p *HTTPReuse) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *HTTPReuse) Result() ([]common.ReturnResultLine, error)
  • func (p *HTTPReuse) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *HTTPReuse) Set(data common.ParserData, index int) error
• type HashType
  • func (p *HashType) Delete(index int) error
  • func (p *HashType) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *HashType) GetOne(index int) (common.ParserData, error)
  • func (p *HashType) GetParserName() string
  • func (p *HashType) Init()
  • func (p *HashType) Insert(data common.ParserData, index int) error
  • func (p *HashType) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *HashType) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *HashType) Result() ([]common.ReturnResultLine, error)
  • func (p *HashType) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *HashType) Set(data common.ParserData, index int) error
• type LoadServerStateFromFile
  • func (p *LoadServerStateFromFile) Delete(index int) error
  • func (p *LoadServerStateFromFile) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *LoadServerStateFromFile) GetOne(index int) (common.ParserData, error)
  • func (p *LoadServerStateFromFile) GetParserName() string
  • func (p *LoadServerStateFromFile) Init()
  • func (p *LoadServerStateFromFile) Insert(data common.ParserData, index int) error
  • func (p *LoadServerStateFromFile) Parse(line string, parts, previousPats []string, comment string) (changeState string, err error)
  • func (p *LoadServerStateFromFile) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *LoadServerStateFromFile) Result() ([]common.ReturnResultLine, error)
  • func (p *LoadServerStateFromFile) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *LoadServerStateFromFile) Set(data common.ParserData, index int) error
• type Log
  • func (p *Log) Delete(index int) error
  • func (p *Log) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Log) GetOne(index int) (common.ParserData, error)
  • func (p *Log) GetParserName() string
  • func (l *Log) Init()
  • func (p *Log) Insert(data common.ParserData, index int) error
  • func (l *Log) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Log) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *Log) Result() ([]common.ReturnResultLine, error)
  • func (p *Log) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Log) Set(data common.ParserData, index int) error
• type LogSendHostName
  • func (p *LogSendHostName) Delete(index int) error
  • func (p *LogSendHostName) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *LogSendHostName) GetOne(index int) (common.ParserData, error)
  • func (p *LogSendHostName) GetParserName() string
  • func (p *LogSendHostName) Init()
  • func (p *LogSendHostName) Insert(data common.ParserData, index int) error
  • func (p *LogSendHostName) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *LogSendHostName) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *LogSendHostName) Result() ([]common.ReturnResultLine, error)
  • func (p *LogSendHostName) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *LogSendHostName) Set(data common.ParserData, index int) error
• type LuaLoad
  • func (p *LuaLoad) Delete(index int) error
  • func (p *LuaLoad) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *LuaLoad) GetOne(index int) (common.ParserData, error)
  • func (p *LuaLoad) GetParserName() string
  • func (p *LuaLoad) Init()
  • func (p *LuaLoad) Insert(data common.ParserData, index int) error
  • func (p *LuaLoad) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *LuaLoad) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *LuaLoad) Result() ([]common.ReturnResultLine, error)
  • func (p *LuaLoad) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *LuaLoad) Set(data common.ParserData, index int) error
• type Mailer
  • func (p *Mailer) Delete(index int) error
  • func (p *Mailer) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Mailer) GetOne(index int) (common.ParserData, error)
  • func (p *Mailer) GetParserName() string
  • func (p *Mailer) Init()
  • func (p *Mailer) Insert(data common.ParserData, index int) error
  • func (p *Mailer) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Mailer) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *Mailer) Result() ([]common.ReturnResultLine, error)
  • func (p *Mailer) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Mailer) Set(data common.ParserData, index int) error
• type MasterWorker
  • func (p *MasterWorker) Delete(index int) error
  • func (p *MasterWorker) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *MasterWorker) GetOne(index int) (common.ParserData, error)
  • func (p *MasterWorker) GetParserName() string
  • func (p *MasterWorker) Init()
  • func (p *MasterWorker) Insert(data common.ParserData, index int) error
  • func (m *MasterWorker) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *MasterWorker) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (m *MasterWorker) Result() ([]common.ReturnResultLine, error)
  • func (p *MasterWorker) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *MasterWorker) Set(data common.ParserData, index int) error
• type MaxConn
  • func (p *MaxConn) Delete(index int) error
  • func (p *MaxConn) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *MaxConn) GetOne(index int) (common.ParserData, error)
  • func (p *MaxConn) GetParserName() string
  • func (p *MaxConn) Init()
  • func (p *MaxConn) Insert(data common.ParserData, index int) error
  • func (p *MaxConn) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *MaxConn) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *MaxConn) Result() ([]common.ReturnResultLine, error)
  • func (p *MaxConn) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *MaxConn) Set(data common.ParserData, index int) error
• type Mode
  • func (p *Mode) Delete(index int) error
  • func (p *Mode) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Mode) GetOne(index int) (common.ParserData, error)
  • func (p *Mode) GetParserName() string
  • func (p *Mode) Init()
  • func (p *Mode) Insert(data common.ParserData, index int) error
  • func (p *Mode) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Mode) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *Mode) Result() ([]common.ReturnResultLine, error)
  • func (p *Mode) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Mode) Set(data common.ParserData, index int) error
• type MonitorFail
  • func (p *MonitorFail) Delete(index int) error
  • func (p *MonitorFail) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *MonitorFail) GetOne(index int) (common.ParserData, error)
  • func (p *MonitorFail) GetParserName() string
  • func (p *MonitorFail) Init()
  • func (p *MonitorFail) Insert(data common.ParserData, index int) error
  • func (p *MonitorFail) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *MonitorFail) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *MonitorFail) Result() ([]common.ReturnResultLine, error)
  • func (p *MonitorFail) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *MonitorFail) Set(data common.ParserData, index int) error
• type MonitorURI
  • func (p *MonitorURI) Delete(index int) error
  • func (p *MonitorURI) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *MonitorURI) GetOne(index int) (common.ParserData, error)
  • func (p *MonitorURI) GetParserName() string
  • func (p *MonitorURI) Init()
  • func (p *MonitorURI) Insert(data common.ParserData, index int) error
  • func (p *MonitorURI) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *MonitorURI) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *MonitorURI) Result() ([]common.ReturnResultLine, error)
  • func (p *MonitorURI) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *MonitorURI) Set(data common.ParserData, index int) error
• type Nameserver
  • func (p *Nameserver) Delete(index int) error
  • func (p *Nameserver) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Nameserver) GetOne(index int) (common.ParserData, error)
  • func (p *Nameserver) GetParserName() string
  • func (p *Nameserver) Init()
  • func (p *Nameserver) Insert(data common.ParserData, index int) error
  • func (p *Nameserver) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Nameserver) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *Nameserver) Result() ([]common.ReturnResultLine, error)
  • func (p *Nameserver) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Nameserver) Set(data common.ParserData, index int) error
• type NbProc
  • func (p *NbProc) Delete(index int) error
  • func (p *NbProc) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *NbProc) GetOne(index int) (common.ParserData, error)
  • func (p *NbProc) GetParserName() string
  • func (p *NbProc) Init()
  • func (p *NbProc) Insert(data common.ParserData, index int) error
  • func (n *NbProc) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *NbProc) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (n *NbProc) Result() ([]common.ReturnResultLine, error)
  • func (p *NbProc) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *NbProc) Set(data common.ParserData, index int) error
• type NbThread
  • func (p *NbThread) Delete(index int) error
  • func (p *NbThread) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *NbThread) GetOne(index int) (common.ParserData, error)
  • func (p *NbThread) GetParserName() string
  • func (p *NbThread) Init()
  • func (p *NbThread) Insert(data common.ParserData, index int) error
  • func (n *NbThread) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *NbThread) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (n *NbThread) Result() ([]common.ReturnResultLine, error)
  • func (p *NbThread) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *NbThread) Set(data common.ParserData, index int) error
• type NoSplice
  • func (p *NoSplice) Delete(index int) error
  • func (p *NoSplice) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *NoSplice) GetOne(index int) (common.ParserData, error)
  • func (p *NoSplice) GetParserName() string
  • func (p *NoSplice) Init()
  • func (p *NoSplice) Insert(data common.ParserData, index int) error
  • func (m *NoSplice) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *NoSplice) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (m *NoSplice) Result() ([]common.ReturnResultLine, error)
  • func (p *NoSplice) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *NoSplice) Set(data common.ParserData, index int) error
• type OptionForwardFor
  • func (p *OptionForwardFor) Delete(index int) error
  • func (p *OptionForwardFor) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *OptionForwardFor) GetOne(index int) (common.ParserData, error)
  • func (p *OptionForwardFor) GetParserName() string
  • func (p *OptionForwardFor) Init()
  • func (p *OptionForwardFor) Insert(data common.ParserData, index int) error
  • func (s *OptionForwardFor) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *OptionForwardFor) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *OptionForwardFor) Result() ([]common.ReturnResultLine, error)
  • func (p *OptionForwardFor) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *OptionForwardFor) Set(data common.ParserData, index int) error
• type OptionHTTPLog
  • func (p *OptionHTTPLog) Delete(index int) error
  • func (p *OptionHTTPLog) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *OptionHTTPLog) GetOne(index int) (common.ParserData, error)
  • func (p *OptionHTTPLog) GetParserName() string
  • func (p *OptionHTTPLog) Init()
  • func (p *OptionHTTPLog) Insert(data common.ParserData, index int) error
  • func (o *OptionHTTPLog) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *OptionHTTPLog) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (o *OptionHTTPLog) Result() ([]common.ReturnResultLine, error)
  • func (p *OptionHTTPLog) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *OptionHTTPLog) Set(data common.ParserData, index int) error
• type OptionHttpchk
  • func (p *OptionHttpchk) Delete(index int) error
  • func (p *OptionHttpchk) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *OptionHttpchk) GetOne(index int) (common.ParserData, error)
  • func (p *OptionHttpchk) GetParserName() string
  • func (p *OptionHttpchk) Init()
  • func (p *OptionHttpchk) Insert(data common.ParserData, index int) error
  • func (s *OptionHttpchk) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *OptionHttpchk) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *OptionHttpchk) Result() ([]common.ReturnResultLine, error)
  • func (p *OptionHttpchk) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *OptionHttpchk) Set(data common.ParserData, index int) error
• type OptionMysqlCheck
  • func (p *OptionMysqlCheck) Delete(index int) error
  • func (p *OptionMysqlCheck) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *OptionMysqlCheck) GetOne(index int) (common.ParserData, error)
  • func (p *OptionMysqlCheck) GetParserName() string
  • func (p *OptionMysqlCheck) Init()
  • func (p *OptionMysqlCheck) Insert(data common.ParserData, index int) error
  • func (s *OptionMysqlCheck) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *OptionMysqlCheck) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *OptionMysqlCheck) Result() ([]common.ReturnResultLine, error)
  • func (p *OptionMysqlCheck) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *OptionMysqlCheck) Set(data common.ParserData, index int) error
• type OptionPgsqlCheck
  • func (p *OptionPgsqlCheck) Delete(index int) error
  • func (p *OptionPgsqlCheck) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *OptionPgsqlCheck) GetOne(index int) (common.ParserData, error)
  • func (p *OptionPgsqlCheck) GetParserName() string
  • func (p *OptionPgsqlCheck) Init()
  • func (p *OptionPgsqlCheck) Insert(data common.ParserData, index int) error
  • func (s *OptionPgsqlCheck) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *OptionPgsqlCheck) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *OptionPgsqlCheck) Result() ([]common.ReturnResultLine, error)
  • func (p *OptionPgsqlCheck) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *OptionPgsqlCheck) Set(data common.ParserData, index int) error
• type OptionRedispatch
  • func (p *OptionRedispatch) Delete(index int) error
  • func (p *OptionRedispatch) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *OptionRedispatch) GetOne(index int) (common.ParserData, error)
  • func (p *OptionRedispatch) GetParserName() string
  • func (p *OptionRedispatch) Init()
  • func (p *OptionRedispatch) Insert(data common.ParserData, index int) error
  • func (s *OptionRedispatch) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *OptionRedispatch) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *OptionRedispatch) Result() ([]common.ReturnResultLine, error)
  • func (p *OptionRedispatch) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *OptionRedispatch) Set(data common.ParserData, index int) error
• type OptionSmtpchk
  • func (p *OptionSmtpchk) Delete(index int) error
  • func (p *OptionSmtpchk) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *OptionSmtpchk) GetOne(index int) (common.ParserData, error)
  • func (p *OptionSmtpchk) GetParserName() string
  • func (p *OptionSmtpchk) Init()
  • func (p *OptionSmtpchk) Insert(data common.ParserData, index int) error
  • func (s *OptionSmtpchk) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *OptionSmtpchk) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *OptionSmtpchk) Result() ([]common.ReturnResultLine, error)
  • func (p *OptionSmtpchk) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *OptionSmtpchk) Set(data common.ParserData, index int) error
• type Peer
  • func (p *Peer) Delete(index int) error
  • func (p *Peer) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Peer) GetOne(index int) (common.ParserData, error)
  • func (p *Peer) GetParserName() string
  • func (p *Peer) Init()
  • func (p *Peer) Insert(data common.ParserData, index int) error
  • func (p *Peer) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Peer) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *Peer) Result() ([]common.ReturnResultLine, error)
  • func (p *Peer) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Peer) Set(data common.ParserData, index int) error
• type Server
  • func (p *Server) Delete(index int) error
  • func (p *Server) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Server) GetOne(index int) (common.ParserData, error)
  • func (p *Server) GetParserName() string
  • func (p *Server) Init()
  • func (p *Server) Insert(data common.ParserData, index int) error
  • func (p *Server) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Server) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *Server) Result() ([]common.ReturnResultLine, error)
  • func (p *Server) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Server) Set(data common.ParserData, index int) error
• type ServerTemplate
  • func (p *ServerTemplate) Delete(index int) error
  • func (p *ServerTemplate) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *ServerTemplate) GetOne(index int) (common.ParserData, error)
  • func (p *ServerTemplate) GetParserName() string
  • func (p *ServerTemplate) Init()
  • func (p *ServerTemplate) Insert(data common.ParserData, index int) error
  • func (h *ServerTemplate) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *ServerTemplate) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *ServerTemplate) Result() ([]common.ReturnResultLine, error)
  • func (p *ServerTemplate) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *ServerTemplate) Set(data common.ParserData, index int) error
• type Socket
  • func (p *Socket) Delete(index int) error
  • func (p *Socket) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Socket) GetOne(index int) (common.ParserData, error)
  • func (p *Socket) GetParserName() string
  • func (p *Socket) Init()
  • func (p *Socket) Insert(data common.ParserData, index int) error
  • func (p *Socket) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Socket) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *Socket) Result() ([]common.ReturnResultLine, error)
  • func (p *Socket) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Socket) Set(data common.ParserData, index int) error
• type SslEngine
  • func (p *SslEngine) Delete(index int) error
  • func (p *SslEngine) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *SslEngine) GetOne(index int) (common.ParserData, error)
  • func (p *SslEngine) GetParserName() string
  • func (p *SslEngine) Init()
  • func (p *SslEngine) Insert(data common.ParserData, index int) error
  • func (p *SslEngine) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *SslEngine) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *SslEngine) Result() ([]common.ReturnResultLine, error)
  • func (p *SslEngine) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *SslEngine) Set(data common.ParserData, index int) error
• type SslModeAsync
  • func (p *SslModeAsync) Delete(index int) error
  • func (p *SslModeAsync) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *SslModeAsync) GetOne(index int) (common.ParserData, error)
  • func (p *SslModeAsync) GetParserName() string
  • func (p *SslModeAsync) Init()
  • func (p *SslModeAsync) Insert(data common.ParserData, index int) error
  • func (p *SslModeAsync) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *SslModeAsync) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *SslModeAsync) Result() (res []common.ReturnResultLine, err error)
  • func (p *SslModeAsync) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *SslModeAsync) Set(data common.ParserData, index int) error
• type StatsTimeout
  • func (p *StatsTimeout) Delete(index int) error
  • func (p *StatsTimeout) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *StatsTimeout) GetOne(index int) (common.ParserData, error)
  • func (p *StatsTimeout) GetParserName() string
  • func (p *StatsTimeout) Init()
  • func (p *StatsTimeout) Insert(data common.ParserData, index int) error
  • func (s *StatsTimeout) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *StatsTimeout) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *StatsTimeout) Result() ([]common.ReturnResultLine, error)
  • func (p *StatsTimeout) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *StatsTimeout) Set(data common.ParserData, index int) error
• type Stick
  • func (p *Stick) Delete(index int) error
  • func (p *Stick) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *Stick) GetOne(index int) (common.ParserData, error)
  • func (p *Stick) GetParserName() string
  • func (p *Stick) Init()
  • func (p *Stick) Insert(data common.ParserData, index int) error
  • func (h *Stick) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *Stick) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *Stick) Result() ([]common.ReturnResultLine, error)
  • func (p *Stick) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *Stick) Set(data common.ParserData, index int) error
• type StickTable
  • func (p *StickTable) Delete(index int) error
  • func (p *StickTable) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *StickTable) GetOne(index int) (common.ParserData, error)
  • func (p *StickTable) GetParserName() string
  • func (p *StickTable) Init()
  • func (p *StickTable) Insert(data common.ParserData, index int) error
  • func (h *StickTable) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *StickTable) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *StickTable) Result() ([]common.ReturnResultLine, error)
  • func (p *StickTable) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *StickTable) Set(data common.ParserData, index int) error
• type UniqueIDFormat
  • func (p *UniqueIDFormat) Delete(index int) error
  • func (p *UniqueIDFormat) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *UniqueIDFormat) GetOne(index int) (common.ParserData, error)
  • func (p *UniqueIDFormat) GetParserName() string
  • func (p *UniqueIDFormat) Init()
  • func (p *UniqueIDFormat) Insert(data common.ParserData, index int) error
  • func (p *UniqueIDFormat) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *UniqueIDFormat) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (p *UniqueIDFormat) Result() ([]common.ReturnResultLine, error)
  • func (p *UniqueIDFormat) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *UniqueIDFormat) Set(data common.ParserData, index int) error
• type UniqueIDHeader
  • func (p *UniqueIDHeader) Delete(index int) error
  • func (p *UniqueIDHeader) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *UniqueIDHeader) GetOne(index int) (common.ParserData, error)
  • func (p *UniqueIDHeader) GetParserName() string
  • func (p *UniqueIDHeader) Init()
  • func (p *UniqueIDHeader) Insert(data common.ParserData, index int) error
  • func (s *UniqueIDHeader) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *UniqueIDHeader) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (s *UniqueIDHeader) Result() ([]common.ReturnResultLine, error)
  • func (p *UniqueIDHeader) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *UniqueIDHeader) Set(data common.ParserData, index int) error
• type UseBackend
  • func (p *UseBackend) Delete(index int) error
  • func (p *UseBackend) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *UseBackend) GetOne(index int) (common.ParserData, error)
  • func (p *UseBackend) GetParserName() string
  • func (p *UseBackend) Init()
  • func (p *UseBackend) Insert(data common.ParserData, index int) error
  • func (p *UseBackend) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *UseBackend) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (h *UseBackend) Result() ([]common.ReturnResultLine, error)
  • func (p *UseBackend) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *UseBackend) Set(data common.ParserData, index int) error
• type UseServer
  • func (p *UseServer) Delete(index int) error
  • func (p *UseServer) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *UseServer) GetOne(index int) (common.ParserData, error)
  • func (p *UseServer) GetParserName() string
  • func (p *UseServer) Init()
  • func (p *UseServer) Insert(data common.ParserData, index int) error
  • func (l *UseServer) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *UseServer) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *UseServer) Result() ([]common.ReturnResultLine, error)
  • func (p *UseServer) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *UseServer) Set(data common.ParserData, index int) error
• type User
  • func (p *User) Delete(index int) error
  • func (p *User) Get(createIfNotExist bool) (common.ParserData, error)
  • func (p *User) GetOne(index int) (common.ParserData, error)
  • func (p *User) GetParserName() string
  • func (p *User) Init()
  • func (p *User) Insert(data common.ParserData, index int) error
  • func (p *User) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)
  • func (p *User) PreParse(line string, parts, previousParts []string, preComments []string, ...) (changeState string, err error)
  • func (l *User) Result() ([]common.ReturnResultLine, error)
  • func (p *User) ResultAll() ([]common.ReturnResultLine, []string, error)
  • func (p *User) Set(data common.ParserData, index int) error

Constants

const CookieKeyword = "cookie"

const ExternalCheckKeyword = "external-check"

Types

type ACL

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

func (*ACL) Delete

func (p *ACL) Delete(index int) error

func (*ACL) Get

func (p *ACL) Get(createIfNotExist bool) (common.ParserData, error)

func (*ACL) GetOne

func (p *ACL) GetOne(index int) (common.ParserData, error)

func (*ACL) GetParserName

func (p *ACL) GetParserName() string

func (*ACL) Init

func (p *ACL) Init()

func (*ACL) Insert

func (p *ACL) Insert(data common.ParserData, index int) error

func (*ACL) Parse

func (p *ACL) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*ACL) PreParse

func (p *ACL) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*ACL) Result

func (h *ACL) Result() ([]common.ReturnResultLine, error)

func (*ACL) ResultAll

func (p *ACL) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*ACL) Set

func (p *ACL) Set(data common.ParserData, index int) error

type Balance

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

func (*Balance) Delete

func (p *Balance) Delete(index int) error

func (*Balance) Get

func (p *Balance) Get(createIfNotExist bool) (common.ParserData, error)

func (*Balance) GetOne

func (p *Balance) GetOne(index int) (common.ParserData, error)

func (*Balance) GetParserName

func (p *Balance) GetParserName() string

func (*Balance) Init

func (p *Balance) Init()

func (*Balance) Insert

func (p *Balance) Insert(data common.ParserData, index int) error

func (*Balance) Parse

func (p *Balance) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Balance) PreParse

func (p *Balance) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Balance) Result

func (p *Balance) Result() ([]common.ReturnResultLine, error)

func (*Balance) ResultAll

func (p *Balance) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Balance) Set

func (p *Balance) Set(data common.ParserData, index int) error

type Bind

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

func (*Bind) Delete

func (p *Bind) Delete(index int) error

func (*Bind) Get

func (p *Bind) Get(createIfNotExist bool) (common.ParserData, error)

func (*Bind) GetOne

func (p *Bind) GetOne(index int) (common.ParserData, error)

func (*Bind) GetParserName

func (p *Bind) GetParserName() string

func (*Bind) Init

func (p *Bind) Init()

func (*Bind) Insert

func (p *Bind) Insert(data common.ParserData, index int) error

func (*Bind) Parse

func (p *Bind) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Bind) PreParse

func (p *Bind) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Bind) Result

func (h *Bind) Result() ([]common.ReturnResultLine, error)

func (*Bind) ResultAll

func (p *Bind) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Bind) Set

func (p *Bind) Set(data common.ParserData, index int) error

type BindProcess

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

func (*BindProcess) Delete

func (p *BindProcess) Delete(index int) error

func (*BindProcess) Get

func (p *BindProcess) Get(createIfNotExist bool) (common.ParserData, error)

func (*BindProcess) GetOne

func (p *BindProcess) GetOne(index int) (common.ParserData, error)

func (*BindProcess) GetParserName

func (p *BindProcess) GetParserName() string

func (*BindProcess) Init

func (p *BindProcess) Init()

func (*BindProcess) Insert

func (p *BindProcess) Insert(data common.ParserData, index int) error

func (*BindProcess) Parse

func (p *BindProcess) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*BindProcess) PreParse

func (p *BindProcess) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*BindProcess) Result

func (p *BindProcess) Result() ([]common.ReturnResultLine, error)

func (*BindProcess) ResultAll

func (p *BindProcess) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*BindProcess) Set

func (p *BindProcess) Set(data common.ParserData, index int) error

type CPUMap

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

func (*CPUMap) Delete

func (p *CPUMap) Delete(index int) error

func (*CPUMap) Equal

func (c *CPUMap) Equal(b *CPUMap) bool

func (*CPUMap) Get

func (p *CPUMap) Get(createIfNotExist bool) (common.ParserData, error)

func (*CPUMap) GetOne

func (p *CPUMap) GetOne(index int) (common.ParserData, error)

func (*CPUMap) GetParserName

func (p *CPUMap) GetParserName() string

func (*CPUMap) Init

func (p *CPUMap) Init()

func (*CPUMap) Insert

func (p *CPUMap) Insert(data common.ParserData, index int) error

func (*CPUMap) Parse

func (p *CPUMap) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*CPUMap) PreParse

func (p *CPUMap) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*CPUMap) Result

func (c *CPUMap) Result() ([]common.ReturnResultLine, error)

func (*CPUMap) ResultAll

func (p *CPUMap) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*CPUMap) Set

func (p *CPUMap) Set(data common.ParserData, index int) error

type ConfigSnippet

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

func (*ConfigSnippet) Delete

func (p *ConfigSnippet) Delete(index int) error

func (*ConfigSnippet) Get

func (p *ConfigSnippet) Get(createIfNotExist bool) (common.ParserData, error)

func (*ConfigSnippet) GetOne

func (p *ConfigSnippet) GetOne(index int) (common.ParserData, error)

func (*ConfigSnippet) GetParserName

func (p *ConfigSnippet) GetParserName() string

func (*ConfigSnippet) Init

func (p *ConfigSnippet) Init()

func (*ConfigSnippet) Insert

func (p *ConfigSnippet) Insert(data common.ParserData, index int) error

func (*ConfigSnippet) Parse

func (p *ConfigSnippet) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*ConfigSnippet) PreParse

func (p *ConfigSnippet) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*ConfigSnippet) Result

func (p *ConfigSnippet) Result() ([]common.ReturnResultLine, error)

func (*ConfigSnippet) ResultAll

func (p *ConfigSnippet) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*ConfigSnippet) Set

func (p *ConfigSnippet) Set(data common.ParserData, index int) error

type Cookie

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

func (*Cookie) Delete

func (p *Cookie) Delete(index int) error

func (*Cookie) Get

func (p *Cookie) Get(createIfNotExist bool) (common.ParserData, error)

func (*Cookie) GetOne

func (p *Cookie) GetOne(index int) (common.ParserData, error)

func (*Cookie) GetParserName

func (p *Cookie) GetParserName() string

func (*Cookie) Init

func (p *Cookie) Init()

func (*Cookie) Insert

func (p *Cookie) Insert(data common.ParserData, index int) error

func (*Cookie) Parse

func (p *Cookie) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Cookie) PreParse

func (p *Cookie) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Cookie) Result

func (p *Cookie) Result() ([]common.ReturnResultLine, error)

func (*Cookie) ResultAll

func (p *Cookie) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Cookie) Set

func (p *Cookie) Set(data common.ParserData, index int) error

type Daemon

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

func (*Daemon) Delete

func (p *Daemon) Delete(index int) error

func (*Daemon) Get

func (p *Daemon) Get(createIfNotExist bool) (common.ParserData, error)

func (*Daemon) GetOne

func (p *Daemon) GetOne(index int) (common.ParserData, error)

func (*Daemon) GetParserName

func (p *Daemon) GetParserName() string

func (*Daemon) Init

func (p *Daemon) Init()

func (*Daemon) Insert

func (p *Daemon) Insert(data common.ParserData, index int) error

func (*Daemon) Parse

func (d *Daemon) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Daemon) PreParse

func (p *Daemon) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Daemon) Result

func (d *Daemon) Result() ([]common.ReturnResultLine, error)

func (*Daemon) ResultAll

func (p *Daemon) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Daemon) Set

func (p *Daemon) Set(data common.ParserData, index int) error

type DefaultBackend

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

func (*DefaultBackend) Delete

func (p *DefaultBackend) Delete(index int) error

func (*DefaultBackend) Get

func (p *DefaultBackend) Get(createIfNotExist bool) (common.ParserData, error)

func (*DefaultBackend) GetOne

func (p *DefaultBackend) GetOne(index int) (common.ParserData, error)

func (*DefaultBackend) GetParserName

func (p *DefaultBackend) GetParserName() string

func (*DefaultBackend) Init

func (p *DefaultBackend) Init()

func (*DefaultBackend) Insert

func (p *DefaultBackend) Insert(data common.ParserData, index int) error

func (*DefaultBackend) Parse

func (s *DefaultBackend) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*DefaultBackend) PreParse

func (p *DefaultBackend) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*DefaultBackend) Result

func (s *DefaultBackend) Result() ([]common.ReturnResultLine, error)

func (*DefaultBackend) ResultAll

func (p *DefaultBackend) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*DefaultBackend) Set

func (p *DefaultBackend) Set(data common.ParserData, index int) error

type DefaultServer

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

func (*DefaultServer) Delete

func (p *DefaultServer) Delete(index int) error

func (*DefaultServer) Get

func (p *DefaultServer) Get(createIfNotExist bool) (common.ParserData, error)

func (*DefaultServer) GetOne

func (p *DefaultServer) GetOne(index int) (common.ParserData, error)

func (*DefaultServer) GetParserName

func (p *DefaultServer) GetParserName() string

func (*DefaultServer) Init

func (p *DefaultServer) Init()

func (*DefaultServer) Insert

func (p *DefaultServer) Insert(data common.ParserData, index int) error

func (*DefaultServer) Parse

func (p *DefaultServer) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*DefaultServer) PreParse

func (p *DefaultServer) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*DefaultServer) Result

func (h *DefaultServer) Result() ([]common.ReturnResultLine, error)

func (*DefaultServer) ResultAll

func (p *DefaultServer) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*DefaultServer) Set

func (p *DefaultServer) Set(data common.ParserData, index int) error

type ErrorFile

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

func (*ErrorFile) Delete

func (p *ErrorFile) Delete(index int) error

func (*ErrorFile) Get

func (p *ErrorFile) Get(createIfNotExist bool) (common.ParserData, error)

func (*ErrorFile) GetOne

func (p *ErrorFile) GetOne(index int) (common.ParserData, error)

func (*ErrorFile) GetParserName

func (p *ErrorFile) GetParserName() string

func (*ErrorFile) Init

func (l *ErrorFile) Init()

func (*ErrorFile) Insert

func (p *ErrorFile) Insert(data common.ParserData, index int) error

func (*ErrorFile) Parse

func (p *ErrorFile) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*ErrorFile) PreParse

func (p *ErrorFile) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*ErrorFile) Result

func (l *ErrorFile) Result() ([]common.ReturnResultLine, error)

func (*ErrorFile) ResultAll

func (p *ErrorFile) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*ErrorFile) Set

func (p *ErrorFile) Set(data common.ParserData, index int) error

type ExternalCheck

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

func (*ExternalCheck) Delete

func (p *ExternalCheck) Delete(index int) error

func (*ExternalCheck) Get

func (p *ExternalCheck) Get(createIfNotExist bool) (common.ParserData, error)

func (*ExternalCheck) GetOne

func (p *ExternalCheck) GetOne(index int) (common.ParserData, error)

func (*ExternalCheck) GetParserName

func (p *ExternalCheck) GetParserName() string

func (*ExternalCheck) Init

func (p *ExternalCheck) Init()

func (*ExternalCheck) Insert

func (p *ExternalCheck) Insert(data common.ParserData, index int) error

func (*ExternalCheck) Parse

func (m *ExternalCheck) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*ExternalCheck) PreParse

func (p *ExternalCheck) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*ExternalCheck) Result

func (m *ExternalCheck) Result() ([]common.ReturnResultLine, error)

func (*ExternalCheck) ResultAll

func (p *ExternalCheck) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*ExternalCheck) Set

func (p *ExternalCheck) Set(data common.ParserData, index int) error

type ExternalCheckCommand

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

func (*ExternalCheckCommand) Delete

func (p *ExternalCheckCommand) Delete(index int) error

func (*ExternalCheckCommand) Get

func (p *ExternalCheckCommand) Get(createIfNotExist bool) (common.ParserData, error)

func (*ExternalCheckCommand) GetOne

func (p *ExternalCheckCommand) GetOne(index int) (common.ParserData, error)

func (*ExternalCheckCommand) GetParserName

func (p *ExternalCheckCommand) GetParserName() string

func (*ExternalCheckCommand) Init

func (p *ExternalCheckCommand) Init()

func (*ExternalCheckCommand) Insert

func (p *ExternalCheckCommand) Insert(data common.ParserData, index int) error

func (*ExternalCheckCommand) Parse

func (s *ExternalCheckCommand) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

external-check command <command>

func (*ExternalCheckCommand) PreParse

func (p *ExternalCheckCommand) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*ExternalCheckCommand) Result

func (s *ExternalCheckCommand) Result() ([]common.ReturnResultLine, error)

func (*ExternalCheckCommand) ResultAll

func (p *ExternalCheckCommand) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*ExternalCheckCommand) Set

func (p *ExternalCheckCommand) Set(data common.ParserData, index int) error

type ExternalCheckPath

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

func (*ExternalCheckPath) Delete

func (p *ExternalCheckPath) Delete(index int) error

func (*ExternalCheckPath) Get

func (p *ExternalCheckPath) Get(createIfNotExist bool) (common.ParserData, error)

func (*ExternalCheckPath) GetOne

func (p *ExternalCheckPath) GetOne(index int) (common.ParserData, error)

func (*ExternalCheckPath) GetParserName

func (p *ExternalCheckPath) GetParserName() string

func (*ExternalCheckPath) Init

func (p *ExternalCheckPath) Init()

func (*ExternalCheckPath) Insert

func (p *ExternalCheckPath) Insert(data common.ParserData, index int) error

func (*ExternalCheckPath) Parse

func (s *ExternalCheckPath) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

external-check path <path>

func (*ExternalCheckPath) PreParse

func (p *ExternalCheckPath) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*ExternalCheckPath) Result

func (s *ExternalCheckPath) Result() ([]common.ReturnResultLine, error)

func (*ExternalCheckPath) ResultAll

func (p *ExternalCheckPath) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*ExternalCheckPath) Set

func (p *ExternalCheckPath) Set(data common.ParserData, index int) error

type Group

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

func (*Group) Delete

func (p *Group) Delete(index int) error

func (*Group) Get

func (p *Group) Get(createIfNotExist bool) (common.ParserData, error)

func (*Group) GetOne

func (p *Group) GetOne(index int) (common.ParserData, error)

func (*Group) GetParserName

func (p *Group) GetParserName() string

func (*Group) Init

func (p *Group) Init()

func (*Group) Insert

func (p *Group) Insert(data common.ParserData, index int) error

func (*Group) Parse

func (p *Group) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Group) PreParse

func (p *Group) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Group) Result

func (l *Group) Result() ([]common.ReturnResultLine, error)

func (*Group) ResultAll

func (p *Group) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Group) Set

func (p *Group) Set(data common.ParserData, index int) error

type HTTPCheckV2

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

func (*HTTPCheckV2) Delete

func (p *HTTPCheckV2) Delete(index int) error

func (*HTTPCheckV2) Get

func (p *HTTPCheckV2) Get(createIfNotExist bool) (common.ParserData, error)

func (*HTTPCheckV2) GetOne

func (p *HTTPCheckV2) GetOne(index int) (common.ParserData, error)

func (*HTTPCheckV2) GetParserName

func (p *HTTPCheckV2) GetParserName() string

func (*HTTPCheckV2) Init

func (p *HTTPCheckV2) Init()

func (*HTTPCheckV2) Insert

func (p *HTTPCheckV2) Insert(data common.ParserData, index int) error

func (*HTTPCheckV2) Parse

func (p *HTTPCheckV2) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*HTTPCheckV2) PreParse

func (p *HTTPCheckV2) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*HTTPCheckV2) Result

func (h *HTTPCheckV2) Result() ([]common.ReturnResultLine, error)

func (*HTTPCheckV2) ResultAll

func (p *HTTPCheckV2) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*HTTPCheckV2) Set

func (p *HTTPCheckV2) Set(data common.ParserData, index int) error

type HTTPReuse

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

func (*HTTPReuse) Delete

func (p *HTTPReuse) Delete(index int) error

func (*HTTPReuse) Get

func (p *HTTPReuse) Get(createIfNotExist bool) (common.ParserData, error)

func (*HTTPReuse) GetOne

func (p *HTTPReuse) GetOne(index int) (common.ParserData, error)

func (*HTTPReuse) GetParserName

func (p *HTTPReuse) GetParserName() string

func (*HTTPReuse) Init

func (p *HTTPReuse) Init()

func (*HTTPReuse) Insert

func (p *HTTPReuse) Insert(data common.ParserData, index int) error

func (*HTTPReuse) Parse

func (p *HTTPReuse) Parse(line string, parts, previousPats []string, comment string) (changeState string, err error)

func (*HTTPReuse) PreParse

func (p *HTTPReuse) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*HTTPReuse) Result

func (p *HTTPReuse) Result() ([]common.ReturnResultLine, error)

func (*HTTPReuse) ResultAll

func (p *HTTPReuse) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*HTTPReuse) Set

func (p *HTTPReuse) Set(data common.ParserData, index int) error

type HashType

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

func (*HashType) Delete

func (p *HashType) Delete(index int) error

func (*HashType) Get

func (p *HashType) Get(createIfNotExist bool) (common.ParserData, error)

func (*HashType) GetOne

func (p *HashType) GetOne(index int) (common.ParserData, error)

func (*HashType) GetParserName

func (p *HashType) GetParserName() string

func (*HashType) Init

func (p *HashType) Init()

func (*HashType) Insert

func (p *HashType) Insert(data common.ParserData, index int) error

func (*HashType) Parse

func (p *HashType) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*HashType) PreParse

func (p *HashType) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*HashType) Result

func (p *HashType) Result() ([]common.ReturnResultLine, error)

func (*HashType) ResultAll

func (p *HashType) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*HashType) Set

func (p *HashType) Set(data common.ParserData, index int) error

type LoadServerStateFromFile

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

func (*LoadServerStateFromFile) Delete

func (p *LoadServerStateFromFile) Delete(index int) error

func (*LoadServerStateFromFile) Get

func (p *LoadServerStateFromFile) Get(createIfNotExist bool) (common.ParserData, error)

func (*LoadServerStateFromFile) GetOne

func (p *LoadServerStateFromFile) GetOne(index int) (common.ParserData, error)

func (*LoadServerStateFromFile) GetParserName

func (p *LoadServerStateFromFile) GetParserName() string

func (*LoadServerStateFromFile) Init

func (p *LoadServerStateFromFile) Init()

func (*LoadServerStateFromFile) Insert

func (p *LoadServerStateFromFile) Insert(data common.ParserData, index int) error

func (*LoadServerStateFromFile) Parse

func (p *LoadServerStateFromFile) Parse(line string, parts, previousPats []string, comment string) (changeState string, err error)

func (*LoadServerStateFromFile) PreParse

func (p *LoadServerStateFromFile) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*LoadServerStateFromFile) Result

func (p *LoadServerStateFromFile) Result() ([]common.ReturnResultLine, error)

func (*LoadServerStateFromFile) ResultAll

func (p *LoadServerStateFromFile) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*LoadServerStateFromFile) Set

func (p *LoadServerStateFromFile) Set(data common.ParserData, index int) error

type Log

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

func (*Log) Delete

func (p *Log) Delete(index int) error

func (*Log) Get

func (p *Log) Get(createIfNotExist bool) (common.ParserData, error)

func (*Log) GetOne

func (p *Log) GetOne(index int) (common.ParserData, error)

func (*Log) GetParserName

func (p *Log) GetParserName() string

func (*Log) Init

func (l *Log) Init()

func (*Log) Insert

func (p *Log) Insert(data common.ParserData, index int) error

func (*Log) Parse

func (l *Log) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Log) PreParse

func (p *Log) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Log) Result

func (l *Log) Result() ([]common.ReturnResultLine, error)

func (*Log) ResultAll

func (p *Log) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Log) Set

func (p *Log) Set(data common.ParserData, index int) error

type LogSendHostName

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

func (*LogSendHostName) Delete

func (p *LogSendHostName) Delete(index int) error

func (*LogSendHostName) Get

func (p *LogSendHostName) Get(createIfNotExist bool) (common.ParserData, error)

func (*LogSendHostName) GetOne

func (p *LogSendHostName) GetOne(index int) (common.ParserData, error)

func (*LogSendHostName) GetParserName

func (p *LogSendHostName) GetParserName() string

func (*LogSendHostName) Init

func (p *LogSendHostName) Init()

func (*LogSendHostName) Insert

func (p *LogSendHostName) Insert(data common.ParserData, index int) error

func (*LogSendHostName) Parse

func (p *LogSendHostName) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*LogSendHostName) PreParse

func (p *LogSendHostName) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*LogSendHostName) Result

func (p *LogSendHostName) Result() ([]common.ReturnResultLine, error)

func (*LogSendHostName) ResultAll

func (p *LogSendHostName) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*LogSendHostName) Set

func (p *LogSendHostName) Set(data common.ParserData, index int) error

type LuaLoad

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

func (*LuaLoad) Delete

func (p *LuaLoad) Delete(index int) error

func (*LuaLoad) Get

func (p *LuaLoad) Get(createIfNotExist bool) (common.ParserData, error)

func (*LuaLoad) GetOne

func (p *LuaLoad) GetOne(index int) (common.ParserData, error)

func (*LuaLoad) GetParserName

func (p *LuaLoad) GetParserName() string

func (*LuaLoad) Init

func (p *LuaLoad) Init()

func (*LuaLoad) Insert

func (p *LuaLoad) Insert(data common.ParserData, index int) error

func (*LuaLoad) Parse

func (p *LuaLoad) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*LuaLoad) PreParse

func (p *LuaLoad) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*LuaLoad) Result

func (l *LuaLoad) Result() ([]common.ReturnResultLine, error)

func (*LuaLoad) ResultAll

func (p *LuaLoad) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*LuaLoad) Set

func (p *LuaLoad) Set(data common.ParserData, index int) error

type Mailer

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

func (*Mailer) Delete

func (p *Mailer) Delete(index int) error

func (*Mailer) Get

func (p *Mailer) Get(createIfNotExist bool) (common.ParserData, error)

func (*Mailer) GetOne

func (p *Mailer) GetOne(index int) (common.ParserData, error)

func (*Mailer) GetParserName

func (p *Mailer) GetParserName() string

func (*Mailer) Init

func (p *Mailer) Init()

func (*Mailer) Insert

func (p *Mailer) Insert(data common.ParserData, index int) error

func (*Mailer) Parse

func (p *Mailer) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Mailer) PreParse

func (p *Mailer) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Mailer) Result

func (l *Mailer) Result() ([]common.ReturnResultLine, error)

func (*Mailer) ResultAll

func (p *Mailer) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Mailer) Set

func (p *Mailer) Set(data common.ParserData, index int) error

type MasterWorker

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

func (*MasterWorker) Delete

func (p *MasterWorker) Delete(index int) error

func (*MasterWorker) Get

func (p *MasterWorker) Get(createIfNotExist bool) (common.ParserData, error)

func (*MasterWorker) GetOne

func (p *MasterWorker) GetOne(index int) (common.ParserData, error)

func (*MasterWorker) GetParserName

func (p *MasterWorker) GetParserName() string

func (*MasterWorker) Init

func (p *MasterWorker) Init()

func (*MasterWorker) Insert

func (p *MasterWorker) Insert(data common.ParserData, index int) error

func (*MasterWorker) Parse

func (m *MasterWorker) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*MasterWorker) PreParse

func (p *MasterWorker) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*MasterWorker) Result

func (m *MasterWorker) Result() ([]common.ReturnResultLine, error)

func (*MasterWorker) ResultAll

func (p *MasterWorker) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*MasterWorker) Set

func (p *MasterWorker) Set(data common.ParserData, index int) error

type MaxConn

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

func (*MaxConn) Delete

func (p *MaxConn) Delete(index int) error

func (*MaxConn) Get

func (p *MaxConn) Get(createIfNotExist bool) (common.ParserData, error)

func (*MaxConn) GetOne

func (p *MaxConn) GetOne(index int) (common.ParserData, error)

func (*MaxConn) GetParserName

func (p *MaxConn) GetParserName() string

func (*MaxConn) Init

func (p *MaxConn) Init()

func (*MaxConn) Insert

func (p *MaxConn) Insert(data common.ParserData, index int) error

func (*MaxConn) Parse

func (p *MaxConn) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*MaxConn) PreParse

func (p *MaxConn) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*MaxConn) Result

func (p *MaxConn) Result() ([]common.ReturnResultLine, error)

func (*MaxConn) ResultAll

func (p *MaxConn) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*MaxConn) Set

func (p *MaxConn) Set(data common.ParserData, index int) error

type Mode

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

func (*Mode) Delete

func (p *Mode) Delete(index int) error

func (*Mode) Get

func (p *Mode) Get(createIfNotExist bool) (common.ParserData, error)

func (*Mode) GetOne

func (p *Mode) GetOne(index int) (common.ParserData, error)

func (*Mode) GetParserName

func (p *Mode) GetParserName() string

func (*Mode) Init

func (p *Mode) Init()

func (*Mode) Insert

func (p *Mode) Insert(data common.ParserData, index int) error

func (*Mode) Parse

func (p *Mode) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Mode) PreParse

func (p *Mode) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Mode) Result

func (p *Mode) Result() ([]common.ReturnResultLine, error)

func (*Mode) ResultAll

func (p *Mode) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Mode) Set

func (p *Mode) Set(data common.ParserData, index int) error

type MonitorFail

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

func (*MonitorFail) Delete

func (p *MonitorFail) Delete(index int) error

func (*MonitorFail) Get

func (p *MonitorFail) Get(createIfNotExist bool) (common.ParserData, error)

func (*MonitorFail) GetOne

func (p *MonitorFail) GetOne(index int) (common.ParserData, error)

func (*MonitorFail) GetParserName

func (p *MonitorFail) GetParserName() string

func (*MonitorFail) Init

func (p *MonitorFail) Init()

func (*MonitorFail) Insert

func (p *MonitorFail) Insert(data common.ParserData, index int) error

func (*MonitorFail) Parse

func (p *MonitorFail) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*MonitorFail) PreParse

func (p *MonitorFail) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*MonitorFail) Result

func (p *MonitorFail) Result() ([]common.ReturnResultLine, error)

func (*MonitorFail) ResultAll

func (p *MonitorFail) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*MonitorFail) Set

func (p *MonitorFail) Set(data common.ParserData, index int) error

type MonitorURI

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

func (*MonitorURI) Delete

func (p *MonitorURI) Delete(index int) error

func (*MonitorURI) Get

func (p *MonitorURI) Get(createIfNotExist bool) (common.ParserData, error)

func (*MonitorURI) GetOne

func (p *MonitorURI) GetOne(index int) (common.ParserData, error)

func (*MonitorURI) GetParserName

func (p *MonitorURI) GetParserName() string

func (*MonitorURI) Init

func (p *MonitorURI) Init()

func (*MonitorURI) Insert

func (p *MonitorURI) Insert(data common.ParserData, index int) error

func (*MonitorURI) Parse

func (p *MonitorURI) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*MonitorURI) PreParse

func (p *MonitorURI) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*MonitorURI) Result

func (p *MonitorURI) Result() ([]common.ReturnResultLine, error)

func (*MonitorURI) ResultAll

func (p *MonitorURI) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*MonitorURI) Set

func (p *MonitorURI) Set(data common.ParserData, index int) error

type Nameserver

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

func (*Nameserver) Delete

func (p *Nameserver) Delete(index int) error

func (*Nameserver) Get

func (p *Nameserver) Get(createIfNotExist bool) (common.ParserData, error)

func (*Nameserver) GetOne

func (p *Nameserver) GetOne(index int) (common.ParserData, error)

func (*Nameserver) GetParserName

func (p *Nameserver) GetParserName() string

func (*Nameserver) Init

func (p *Nameserver) Init()

func (*Nameserver) Insert

func (p *Nameserver) Insert(data common.ParserData, index int) error

func (*Nameserver) Parse

func (p *Nameserver) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Nameserver) PreParse

func (p *Nameserver) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Nameserver) Result

func (l *Nameserver) Result() ([]common.ReturnResultLine, error)

func (*Nameserver) ResultAll

func (p *Nameserver) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Nameserver) Set

func (p *Nameserver) Set(data common.ParserData, index int) error

type NbProc

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

func (*NbProc) Delete

func (p *NbProc) Delete(index int) error

func (*NbProc) Get

func (p *NbProc) Get(createIfNotExist bool) (common.ParserData, error)

func (*NbProc) GetOne

func (p *NbProc) GetOne(index int) (common.ParserData, error)

func (*NbProc) GetParserName

func (p *NbProc) GetParserName() string

func (*NbProc) Init

func (p *NbProc) Init()

func (*NbProc) Insert

func (p *NbProc) Insert(data common.ParserData, index int) error

func (*NbProc) Parse

func (n *NbProc) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*NbProc) PreParse

func (p *NbProc) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*NbProc) Result

func (n *NbProc) Result() ([]common.ReturnResultLine, error)

func (*NbProc) ResultAll

func (p *NbProc) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*NbProc) Set

func (p *NbProc) Set(data common.ParserData, index int) error

type NbThread

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

func (*NbThread) Delete

func (p *NbThread) Delete(index int) error

func (*NbThread) Get

func (p *NbThread) Get(createIfNotExist bool) (common.ParserData, error)

func (*NbThread) GetOne

func (p *NbThread) GetOne(index int) (common.ParserData, error)

func (*NbThread) GetParserName

func (p *NbThread) GetParserName() string

func (*NbThread) Init

func (p *NbThread) Init()

func (*NbThread) Insert

func (p *NbThread) Insert(data common.ParserData, index int) error

func (*NbThread) Parse

func (n *NbThread) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*NbThread) PreParse

func (p *NbThread) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*NbThread) Result

func (n *NbThread) Result() ([]common.ReturnResultLine, error)

func (*NbThread) ResultAll

func (p *NbThread) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*NbThread) Set

func (p *NbThread) Set(data common.ParserData, index int) error

type NoSplice

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

func (*NoSplice) Delete

func (p *NoSplice) Delete(index int) error

func (*NoSplice) Get

func (p *NoSplice) Get(createIfNotExist bool) (common.ParserData, error)

func (*NoSplice) GetOne

func (p *NoSplice) GetOne(index int) (common.ParserData, error)

func (*NoSplice) GetParserName

func (p *NoSplice) GetParserName() string

func (*NoSplice) Init

func (p *NoSplice) Init()

func (*NoSplice) Insert

func (p *NoSplice) Insert(data common.ParserData, index int) error

func (*NoSplice) Parse

func (m *NoSplice) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*NoSplice) PreParse

func (p *NoSplice) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*NoSplice) Result

func (m *NoSplice) Result() ([]common.ReturnResultLine, error)

func (*NoSplice) ResultAll

func (p *NoSplice) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*NoSplice) Set

func (p *NoSplice) Set(data common.ParserData, index int) error

type OptionForwardFor

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

func (*OptionForwardFor) Delete

func (p *OptionForwardFor) Delete(index int) error

func (*OptionForwardFor) Get

func (p *OptionForwardFor) Get(createIfNotExist bool) (common.ParserData, error)

func (*OptionForwardFor) GetOne

func (p *OptionForwardFor) GetOne(index int) (common.ParserData, error)

func (*OptionForwardFor) GetParserName

func (p *OptionForwardFor) GetParserName() string

func (*OptionForwardFor) Init

func (p *OptionForwardFor) Init()

func (*OptionForwardFor) Insert

func (p *OptionForwardFor) Insert(data common.ParserData, index int) error

func (*OptionForwardFor) Parse

func (s *OptionForwardFor) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

option forwardfor [ except <network> ] [ header <name> ] [ if-none ]

func (*OptionForwardFor) PreParse

func (p *OptionForwardFor) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*OptionForwardFor) Result

func (s *OptionForwardFor) Result() ([]common.ReturnResultLine, error)

func (*OptionForwardFor) ResultAll

func (p *OptionForwardFor) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*OptionForwardFor) Set

func (p *OptionForwardFor) Set(data common.ParserData, index int) error

type OptionHTTPLog

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

func (*OptionHTTPLog) Delete

func (p *OptionHTTPLog) Delete(index int) error

func (*OptionHTTPLog) Get

func (p *OptionHTTPLog) Get(createIfNotExist bool) (common.ParserData, error)

func (*OptionHTTPLog) GetOne

func (p *OptionHTTPLog) GetOne(index int) (common.ParserData, error)

func (*OptionHTTPLog) GetParserName

func (p *OptionHTTPLog) GetParserName() string

func (*OptionHTTPLog) Init

func (p *OptionHTTPLog) Init()

func (*OptionHTTPLog) Insert

func (p *OptionHTTPLog) Insert(data common.ParserData, index int) error

func (*OptionHTTPLog) Parse

func (o *OptionHTTPLog) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*OptionHTTPLog) PreParse

func (p *OptionHTTPLog) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*OptionHTTPLog) Result

func (o *OptionHTTPLog) Result() ([]common.ReturnResultLine, error)

func (*OptionHTTPLog) ResultAll

func (p *OptionHTTPLog) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*OptionHTTPLog) Set

func (p *OptionHTTPLog) Set(data common.ParserData, index int) error

type OptionHttpchk

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

func (*OptionHttpchk) Delete

func (p *OptionHttpchk) Delete(index int) error

func (*OptionHttpchk) Get

func (p *OptionHttpchk) Get(createIfNotExist bool) (common.ParserData, error)

func (*OptionHttpchk) GetOne

func (p *OptionHttpchk) GetOne(index int) (common.ParserData, error)

func (*OptionHttpchk) GetParserName

func (p *OptionHttpchk) GetParserName() string

func (*OptionHttpchk) Init

func (p *OptionHttpchk) Init()

func (*OptionHttpchk) Insert

func (p *OptionHttpchk) Insert(data common.ParserData, index int) error

func (*OptionHttpchk) Parse

func (s *OptionHttpchk) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

option httpchk <uri> option httpchk <method> <uri> option httpchk <method> <uri> <version>

func (*OptionHttpchk) PreParse

func (p *OptionHttpchk) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*OptionHttpchk) Result

func (s *OptionHttpchk) Result() ([]common.ReturnResultLine, error)

func (*OptionHttpchk) ResultAll

func (p *OptionHttpchk) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*OptionHttpchk) Set

func (p *OptionHttpchk) Set(data common.ParserData, index int) error

type OptionMysqlCheck

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

func (*OptionMysqlCheck) Delete

func (p *OptionMysqlCheck) Delete(index int) error

func (*OptionMysqlCheck) Get

func (p *OptionMysqlCheck) Get(createIfNotExist bool) (common.ParserData, error)

func (*OptionMysqlCheck) GetOne

func (p *OptionMysqlCheck) GetOne(index int) (common.ParserData, error)

func (*OptionMysqlCheck) GetParserName

func (p *OptionMysqlCheck) GetParserName() string

func (*OptionMysqlCheck) Init

func (p *OptionMysqlCheck) Init()

func (*OptionMysqlCheck) Insert

func (p *OptionMysqlCheck) Insert(data common.ParserData, index int) error

func (*OptionMysqlCheck) Parse

func (s *OptionMysqlCheck) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

option mysql-check [ user <username> [ post-41 ] ]

func (*OptionMysqlCheck) PreParse

func (p *OptionMysqlCheck) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*OptionMysqlCheck) Result

func (s *OptionMysqlCheck) Result() ([]common.ReturnResultLine, error)

func (*OptionMysqlCheck) ResultAll

func (p *OptionMysqlCheck) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*OptionMysqlCheck) Set

func (p *OptionMysqlCheck) Set(data common.ParserData, index int) error

type OptionPgsqlCheck

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

func (*OptionPgsqlCheck) Delete

func (p *OptionPgsqlCheck) Delete(index int) error

func (*OptionPgsqlCheck) Get

func (p *OptionPgsqlCheck) Get(createIfNotExist bool) (common.ParserData, error)

func (*OptionPgsqlCheck) GetOne

func (p *OptionPgsqlCheck) GetOne(index int) (common.ParserData, error)

func (*OptionPgsqlCheck) GetParserName

func (p *OptionPgsqlCheck) GetParserName() string

func (*OptionPgsqlCheck) Init

func (p *OptionPgsqlCheck) Init()

func (*OptionPgsqlCheck) Insert

func (p *OptionPgsqlCheck) Insert(data common.ParserData, index int) error

func (*OptionPgsqlCheck) Parse

func (s *OptionPgsqlCheck) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

option pgsql-check [ user <username> ]

func (*OptionPgsqlCheck) PreParse

func (p *OptionPgsqlCheck) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*OptionPgsqlCheck) Result

func (s *OptionPgsqlCheck) Result() ([]common.ReturnResultLine, error)

func (*OptionPgsqlCheck) ResultAll

func (p *OptionPgsqlCheck) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*OptionPgsqlCheck) Set

func (p *OptionPgsqlCheck) Set(data common.ParserData, index int) error

type OptionRedispatch

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

func (*OptionRedispatch) Delete

func (p *OptionRedispatch) Delete(index int) error

func (*OptionRedispatch) Get

func (p *OptionRedispatch) Get(createIfNotExist bool) (common.ParserData, error)

func (*OptionRedispatch) GetOne

func (p *OptionRedispatch) GetOne(index int) (common.ParserData, error)

func (*OptionRedispatch) GetParserName

func (p *OptionRedispatch) GetParserName() string

func (*OptionRedispatch) Init

func (p *OptionRedispatch) Init()

func (*OptionRedispatch) Insert

func (p *OptionRedispatch) Insert(data common.ParserData, index int) error

func (*OptionRedispatch) Parse

func (s *OptionRedispatch) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

option redispatch <interval>

func (*OptionRedispatch) PreParse

func (p *OptionRedispatch) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*OptionRedispatch) Result

func (s *OptionRedispatch) Result() ([]common.ReturnResultLine, error)

func (*OptionRedispatch) ResultAll

func (p *OptionRedispatch) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*OptionRedispatch) Set

func (p *OptionRedispatch) Set(data common.ParserData, index int) error

type OptionSmtpchk

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

func (*OptionSmtpchk) Delete

func (p *OptionSmtpchk) Delete(index int) error

func (*OptionSmtpchk) Get

func (p *OptionSmtpchk) Get(createIfNotExist bool) (common.ParserData, error)

func (*OptionSmtpchk) GetOne

func (p *OptionSmtpchk) GetOne(index int) (common.ParserData, error)

func (*OptionSmtpchk) GetParserName

func (p *OptionSmtpchk) GetParserName() string

func (*OptionSmtpchk) Init

func (p *OptionSmtpchk) Init()

func (*OptionSmtpchk) Insert

func (p *OptionSmtpchk) Insert(data common.ParserData, index int) error

func (*OptionSmtpchk) Parse

func (s *OptionSmtpchk) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

option smtpchk <hello> <domain>

func (*OptionSmtpchk) PreParse

func (p *OptionSmtpchk) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*OptionSmtpchk) Result

func (s *OptionSmtpchk) Result() ([]common.ReturnResultLine, error)

func (*OptionSmtpchk) ResultAll

func (p *OptionSmtpchk) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*OptionSmtpchk) Set

func (p *OptionSmtpchk) Set(data common.ParserData, index int) error

type Peer

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

func (*Peer) Delete

func (p *Peer) Delete(index int) error

func (*Peer) Get

func (p *Peer) Get(createIfNotExist bool) (common.ParserData, error)

func (*Peer) GetOne

func (p *Peer) GetOne(index int) (common.ParserData, error)

func (*Peer) GetParserName

func (p *Peer) GetParserName() string

func (*Peer) Init

func (p *Peer) Init()

func (*Peer) Insert

func (p *Peer) Insert(data common.ParserData, index int) error

func (*Peer) Parse

func (p *Peer) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Peer) PreParse

func (p *Peer) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Peer) Result

func (l *Peer) Result() ([]common.ReturnResultLine, error)

func (*Peer) ResultAll

func (p *Peer) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Peer) Set

func (p *Peer) Set(data common.ParserData, index int) error

type Server

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

func (*Server) Delete

func (p *Server) Delete(index int) error

func (*Server) Get

func (p *Server) Get(createIfNotExist bool) (common.ParserData, error)

func (*Server) GetOne

func (p *Server) GetOne(index int) (common.ParserData, error)

func (*Server) GetParserName

func (p *Server) GetParserName() string

func (*Server) Init

func (p *Server) Init()

func (*Server) Insert

func (p *Server) Insert(data common.ParserData, index int) error

func (*Server) Parse

func (p *Server) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Server) PreParse

func (p *Server) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Server) Result

func (h *Server) Result() ([]common.ReturnResultLine, error)

func (*Server) ResultAll

func (p *Server) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Server) Set

func (p *Server) Set(data common.ParserData, index int) error

type ServerTemplate

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

func (*ServerTemplate) Delete

func (p *ServerTemplate) Delete(index int) error

func (*ServerTemplate) Get

func (p *ServerTemplate) Get(createIfNotExist bool) (common.ParserData, error)

func (*ServerTemplate) GetOne

func (p *ServerTemplate) GetOne(index int) (common.ParserData, error)

func (*ServerTemplate) GetParserName

func (p *ServerTemplate) GetParserName() string

func (*ServerTemplate) Init

func (p *ServerTemplate) Init()

func (*ServerTemplate) Insert

func (p *ServerTemplate) Insert(data common.ParserData, index int) error

func (*ServerTemplate) Parse

func (h *ServerTemplate) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*ServerTemplate) PreParse

func (p *ServerTemplate) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*ServerTemplate) Result

func (h *ServerTemplate) Result() ([]common.ReturnResultLine, error)

func (*ServerTemplate) ResultAll

func (p *ServerTemplate) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*ServerTemplate) Set

func (p *ServerTemplate) Set(data common.ParserData, index int) error

type Socket

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

func (*Socket) Delete

func (p *Socket) Delete(index int) error

func (*Socket) Get

func (p *Socket) Get(createIfNotExist bool) (common.ParserData, error)

func (*Socket) GetOne

func (p *Socket) GetOne(index int) (common.ParserData, error)

func (*Socket) GetParserName

func (p *Socket) GetParserName() string

func (*Socket) Init

func (p *Socket) Init()

func (*Socket) Insert

func (p *Socket) Insert(data common.ParserData, index int) error

func (*Socket) Parse

func (p *Socket) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Socket) PreParse

func (p *Socket) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Socket) Result

func (l *Socket) Result() ([]common.ReturnResultLine, error)

func (*Socket) ResultAll

func (p *Socket) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Socket) Set

func (p *Socket) Set(data common.ParserData, index int) error

type SslEngine

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

func (*SslEngine) Delete

func (p *SslEngine) Delete(index int) error

func (*SslEngine) Get

func (p *SslEngine) Get(createIfNotExist bool) (common.ParserData, error)

func (*SslEngine) GetOne

func (p *SslEngine) GetOne(index int) (common.ParserData, error)

func (*SslEngine) GetParserName

func (p *SslEngine) GetParserName() string

func (*SslEngine) Init

func (p *SslEngine) Init()

func (*SslEngine) Insert

func (p *SslEngine) Insert(data common.ParserData, index int) error

func (*SslEngine) Parse

func (p *SslEngine) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*SslEngine) PreParse

func (p *SslEngine) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*SslEngine) Result

func (p *SslEngine) Result() ([]common.ReturnResultLine, error)

func (*SslEngine) ResultAll

func (p *SslEngine) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*SslEngine) Set

func (p *SslEngine) Set(data common.ParserData, index int) error

type SslModeAsync

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

func (*SslModeAsync) Delete

func (p *SslModeAsync) Delete(index int) error

func (*SslModeAsync) Get

func (p *SslModeAsync) Get(createIfNotExist bool) (common.ParserData, error)

func (*SslModeAsync) GetOne

func (p *SslModeAsync) GetOne(index int) (common.ParserData, error)

func (*SslModeAsync) GetParserName

func (p *SslModeAsync) GetParserName() string

func (*SslModeAsync) Init

func (p *SslModeAsync) Init()

func (*SslModeAsync) Insert

func (p *SslModeAsync) Insert(data common.ParserData, index int) error

func (*SslModeAsync) Parse

func (p *SslModeAsync) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*SslModeAsync) PreParse

func (p *SslModeAsync) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*SslModeAsync) Result

func (p *SslModeAsync) Result() (res []common.ReturnResultLine, err error)

func (*SslModeAsync) ResultAll

func (p *SslModeAsync) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*SslModeAsync) Set

func (p *SslModeAsync) Set(data common.ParserData, index int) error

type StatsTimeout

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

func (*StatsTimeout) Delete

func (p *StatsTimeout) Delete(index int) error

func (*StatsTimeout) Get

func (p *StatsTimeout) Get(createIfNotExist bool) (common.ParserData, error)

func (*StatsTimeout) GetOne

func (p *StatsTimeout) GetOne(index int) (common.ParserData, error)

func (*StatsTimeout) GetParserName

func (p *StatsTimeout) GetParserName() string

func (*StatsTimeout) Init

func (p *StatsTimeout) Init()

func (*StatsTimeout) Insert

func (p *StatsTimeout) Insert(data common.ParserData, index int) error

func (*StatsTimeout) Parse

func (s *StatsTimeout) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*StatsTimeout) PreParse

func (p *StatsTimeout) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*StatsTimeout) Result

func (s *StatsTimeout) Result() ([]common.ReturnResultLine, error)

func (*StatsTimeout) ResultAll

func (p *StatsTimeout) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*StatsTimeout) Set

func (p *StatsTimeout) Set(data common.ParserData, index int) error

type Stick

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

func (*Stick) Delete

func (p *Stick) Delete(index int) error

func (*Stick) Get

func (p *Stick) Get(createIfNotExist bool) (common.ParserData, error)

func (*Stick) GetOne

func (p *Stick) GetOne(index int) (common.ParserData, error)

func (*Stick) GetParserName

func (p *Stick) GetParserName() string

func (*Stick) Init

func (p *Stick) Init()

func (*Stick) Insert

func (p *Stick) Insert(data common.ParserData, index int) error

func (*Stick) Parse

func (h *Stick) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*Stick) PreParse

func (p *Stick) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*Stick) Result

func (h *Stick) Result() ([]common.ReturnResultLine, error)

func (*Stick) ResultAll

func (p *Stick) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*Stick) Set

func (p *Stick) Set(data common.ParserData, index int) error

type StickTable

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

func (*StickTable) Delete

func (p *StickTable) Delete(index int) error

func (*StickTable) Get

func (p *StickTable) Get(createIfNotExist bool) (common.ParserData, error)

func (*StickTable) GetOne

func (p *StickTable) GetOne(index int) (common.ParserData, error)

func (*StickTable) GetParserName

func (p *StickTable) GetParserName() string

func (*StickTable) Init

func (p *StickTable) Init()

func (*StickTable) Insert

func (p *StickTable) Insert(data common.ParserData, index int) error

func (*StickTable) Parse

func (h *StickTable) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*StickTable) PreParse

func (p *StickTable) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*StickTable) Result

func (h *StickTable) Result() ([]common.ReturnResultLine, error)

func (*StickTable) ResultAll

func (p *StickTable) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*StickTable) Set

func (p *StickTable) Set(data common.ParserData, index int) error

type UniqueIDFormat

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

func (*UniqueIDFormat) Delete

func (p *UniqueIDFormat) Delete(index int) error

func (*UniqueIDFormat) Get

func (p *UniqueIDFormat) Get(createIfNotExist bool) (common.ParserData, error)

func (*UniqueIDFormat) GetOne

func (p *UniqueIDFormat) GetOne(index int) (common.ParserData, error)

func (*UniqueIDFormat) GetParserName

func (p *UniqueIDFormat) GetParserName() string

func (*UniqueIDFormat) Init

func (p *UniqueIDFormat) Init()

func (*UniqueIDFormat) Insert

func (p *UniqueIDFormat) Insert(data common.ParserData, index int) error

func (*UniqueIDFormat) Parse

func (p *UniqueIDFormat) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*UniqueIDFormat) PreParse

func (p *UniqueIDFormat) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*UniqueIDFormat) Result

func (p *UniqueIDFormat) Result() ([]common.ReturnResultLine, error)

func (*UniqueIDFormat) ResultAll

func (p *UniqueIDFormat) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*UniqueIDFormat) Set

func (p *UniqueIDFormat) Set(data common.ParserData, index int) error

type UniqueIDHeader

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

func (*UniqueIDHeader) Delete

func (p *UniqueIDHeader) Delete(index int) error

func (*UniqueIDHeader) Get

func (p *UniqueIDHeader) Get(createIfNotExist bool) (common.ParserData, error)

func (*UniqueIDHeader) GetOne

func (p *UniqueIDHeader) GetOne(index int) (common.ParserData, error)

func (*UniqueIDHeader) GetParserName

func (p *UniqueIDHeader) GetParserName() string

func (*UniqueIDHeader) Init

func (p *UniqueIDHeader) Init()

func (*UniqueIDHeader) Insert

func (p *UniqueIDHeader) Insert(data common.ParserData, index int) error

func (*UniqueIDHeader) Parse

func (s *UniqueIDHeader) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*UniqueIDHeader) PreParse

func (p *UniqueIDHeader) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*UniqueIDHeader) Result

func (s *UniqueIDHeader) Result() ([]common.ReturnResultLine, error)

func (*UniqueIDHeader) ResultAll

func (p *UniqueIDHeader) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*UniqueIDHeader) Set

func (p *UniqueIDHeader) Set(data common.ParserData, index int) error

type UseBackend

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

func (*UseBackend) Delete

func (p *UseBackend) Delete(index int) error

func (*UseBackend) Get

func (p *UseBackend) Get(createIfNotExist bool) (common.ParserData, error)

func (*UseBackend) GetOne

func (p *UseBackend) GetOne(index int) (common.ParserData, error)

func (*UseBackend) GetParserName

func (p *UseBackend) GetParserName() string

func (*UseBackend) Init

func (p *UseBackend) Init()

func (*UseBackend) Insert

func (p *UseBackend) Insert(data common.ParserData, index int) error

func (*UseBackend) Parse

func (p *UseBackend) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*UseBackend) PreParse

func (p *UseBackend) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*UseBackend) Result

func (h *UseBackend) Result() ([]common.ReturnResultLine, error)

func (*UseBackend) ResultAll

func (p *UseBackend) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*UseBackend) Set

func (p *UseBackend) Set(data common.ParserData, index int) error

type UseServer

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

func (*UseServer) Delete

func (p *UseServer) Delete(index int) error

func (*UseServer) Get

func (p *UseServer) Get(createIfNotExist bool) (common.ParserData, error)

func (*UseServer) GetOne

func (p *UseServer) GetOne(index int) (common.ParserData, error)

func (*UseServer) GetParserName

func (p *UseServer) GetParserName() string

func (*UseServer) Init

func (p *UseServer) Init()

func (*UseServer) Insert

func (p *UseServer) Insert(data common.ParserData, index int) error

func (*UseServer) Parse

func (l *UseServer) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*UseServer) PreParse

func (p *UseServer) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*UseServer) Result

func (l *UseServer) Result() ([]common.ReturnResultLine, error)

func (*UseServer) ResultAll

func (p *UseServer) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*UseServer) Set

func (p *UseServer) Set(data common.ParserData, index int) error

type User

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

func (*User) Delete

func (p *User) Delete(index int) error

func (*User) Get

func (p *User) Get(createIfNotExist bool) (common.ParserData, error)

func (*User) GetOne

func (p *User) GetOne(index int) (common.ParserData, error)

func (*User) GetParserName

func (p *User) GetParserName() string

func (*User) Init

func (p *User) Init()

func (*User) Insert

func (p *User) Insert(data common.ParserData, index int) error

func (*User) Parse

func (p *User) Parse(line string, parts, previousParts []string, comment string) (changeState string, err error)

func (*User) PreParse

func (p *User) PreParse(line string, parts, previousParts []string, preComments []string, comment string) (changeState string, err error)

func (*User) Result

func (l *User) Result() ([]common.ReturnResultLine, error)

func (*User) ResultAll

func (p *User) ResultAll() ([]common.ReturnResultLine, []string, error)

func (*User) Set

func (p *User) Set(data common.ParserData, index int) error