parsers

package
v6.0.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 10, 2024 License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Overview

Code generated by go generate; DO NOT EDIT.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

View Source 
const CookieKeyword = "cookie"
View Source 
const ExternalCheckKeyword = "external-check"

Variables

This section is empty.

Functions

func CheckParsePair 

func CheckParsePair(parts []string, i *int, str *string)

func CheckWritePair 

func CheckWritePair(sb io.StringWriter, key string, value string)

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) GetPreComments 

func (p *ACL) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*ACL) PreParse 

func (p *ACL) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*ACL) SetPreComments 

func (p *ACL) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Balance) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Balance) PreParse 

func (p *Balance) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Balance) SetPreComments 

func (p *Balance) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Bind) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Bind) PreParse 

func (p *Bind) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Bind) SetPreComments 

func (p *Bind) SetPreComments(preComments []string)

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) GetPreComments 

func (p *BindProcess) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*BindProcess) PreParse 

func (p *BindProcess) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*BindProcess) SetPreComments 

func (p *BindProcess) SetPreComments(preComments []string)

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) GetPreComments 

func (p *CPUMap) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*CPUMap) PreParse 

func (p *CPUMap) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*CPUMap) SetPreComments 

func (p *CPUMap) SetPreComments(preComments []string)

type Command 

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

func (*Command) Delete 

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

func (*Command) Get 

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

func (*Command) GetOne 

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

func (*Command) GetParserName 

func (p *Command) GetParserName() string

func (*Command) GetPreComments 

func (p *Command) GetPreComments() ([]string, error)

func (*Command) Init 

func (p *Command) Init()

func (*Command) Insert 

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

func (*Command) Parse 

func (p *Command) Parse(line string, parts []string, comment string) (string, error)

func (*Command) PreParse 

func (p *Command) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*Command) Result 

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

func (*Command) ResultAll 

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

func (*Command) Set 

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

func (*Command) SetPreComments 

func (p *Command) SetPreComments(preComments []string)

type CompressionAlgo 

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

func (*CompressionAlgo) Delete 

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

func (*CompressionAlgo) Get 

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

func (*CompressionAlgo) GetOne 

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

func (*CompressionAlgo) GetParserName 

func (p *CompressionAlgo) GetParserName() string

func (*CompressionAlgo) GetPreComments 

func (p *CompressionAlgo) GetPreComments() ([]string, error)

func (*CompressionAlgo) Init 

func (p *CompressionAlgo) Init()

func (*CompressionAlgo) Insert 

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

func (*CompressionAlgo) Parse 

func (c *CompressionAlgo) Parse(line string, parts []string, comment string) (string, error)

func (*CompressionAlgo) PreParse 

func (p *CompressionAlgo) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*CompressionAlgo) Result 

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

func (*CompressionAlgo) ResultAll 

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

func (*CompressionAlgo) Set 

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

func (*CompressionAlgo) SetPreComments 

func (p *CompressionAlgo) SetPreComments(preComments []string)

type CompressionAlgoReq 

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

func (*CompressionAlgoReq) Delete 

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

func (*CompressionAlgoReq) Get 

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

func (*CompressionAlgoReq) GetOne 

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

func (*CompressionAlgoReq) GetParserName 

func (p *CompressionAlgoReq) GetParserName() string

func (*CompressionAlgoReq) GetPreComments 

func (p *CompressionAlgoReq) GetPreComments() ([]string, error)

func (*CompressionAlgoReq) Init 

func (p *CompressionAlgoReq) Init()

func (*CompressionAlgoReq) Insert 

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

func (*CompressionAlgoReq) Parse 

func (c *CompressionAlgoReq) Parse(line string, parts []string, comment string) (string, error)

func (*CompressionAlgoReq) PreParse 

func (p *CompressionAlgoReq) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*CompressionAlgoReq) Result 

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

func (*CompressionAlgoReq) ResultAll 

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

func (*CompressionAlgoReq) Set 

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

func (*CompressionAlgoReq) SetPreComments 

func (p *CompressionAlgoReq) SetPreComments(preComments []string)

type CompressionAlgoRes 

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

func (*CompressionAlgoRes) Delete 

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

func (*CompressionAlgoRes) Get 

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

func (*CompressionAlgoRes) GetOne 

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

func (*CompressionAlgoRes) GetParserName 

func (p *CompressionAlgoRes) GetParserName() string

func (*CompressionAlgoRes) GetPreComments 

func (p *CompressionAlgoRes) GetPreComments() ([]string, error)

func (*CompressionAlgoRes) Init 

func (p *CompressionAlgoRes) Init()

func (*CompressionAlgoRes) Insert 

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

func (*CompressionAlgoRes) Parse 

func (c *CompressionAlgoRes) Parse(line string, parts []string, comment string) (string, error)

func (*CompressionAlgoRes) PreParse 

func (p *CompressionAlgoRes) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*CompressionAlgoRes) Result 

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

func (*CompressionAlgoRes) ResultAll 

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

func (*CompressionAlgoRes) Set 

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

func (*CompressionAlgoRes) SetPreComments 

func (p *CompressionAlgoRes) SetPreComments(preComments []string)

type CompressionDirection 

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

func (*CompressionDirection) Delete 

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

func (*CompressionDirection) Get 

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

func (*CompressionDirection) GetOne 

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

func (*CompressionDirection) GetParserName 

func (p *CompressionDirection) GetParserName() string

func (*CompressionDirection) GetPreComments 

func (p *CompressionDirection) GetPreComments() ([]string, error)

func (*CompressionDirection) Init 

func (p *CompressionDirection) Init()

func (*CompressionDirection) Insert 

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

func (*CompressionDirection) Parse 

func (c *CompressionDirection) Parse(line string, parts []string, comment string) (string, error)

func (*CompressionDirection) PreParse 

func (p *CompressionDirection) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*CompressionDirection) Result 

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

func (*CompressionDirection) ResultAll 

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

func (*CompressionDirection) Set 

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

func (*CompressionDirection) SetPreComments 

func (p *CompressionDirection) SetPreComments(preComments []string)

type CompressionOffload 

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

func (*CompressionOffload) Delete 

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

func (*CompressionOffload) Get 

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

func (*CompressionOffload) GetOne 

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

func (*CompressionOffload) GetParserName 

func (p *CompressionOffload) GetParserName() string

func (*CompressionOffload) GetPreComments 

func (p *CompressionOffload) GetPreComments() ([]string, error)

func (*CompressionOffload) Init 

func (p *CompressionOffload) Init()

func (*CompressionOffload) Insert 

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

func (*CompressionOffload) Parse 

func (c *CompressionOffload) Parse(line string, parts []string, comment string) (string, error)

func (*CompressionOffload) PreParse 

func (p *CompressionOffload) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*CompressionOffload) Result 

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

func (*CompressionOffload) ResultAll 

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

func (*CompressionOffload) Set 

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

func (*CompressionOffload) SetPreComments 

func (p *CompressionOffload) SetPreComments(preComments []string)

type CompressionType 

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

func (*CompressionType) Delete 

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

func (*CompressionType) Get 

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

func (*CompressionType) GetOne 

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

func (*CompressionType) GetParserName 

func (p *CompressionType) GetParserName() string

func (*CompressionType) GetPreComments 

func (p *CompressionType) GetPreComments() ([]string, error)

func (*CompressionType) Init 

func (p *CompressionType) Init()

func (*CompressionType) Insert 

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

func (*CompressionType) Parse 

func (c *CompressionType) Parse(line string, parts []string, comment string) (string, error)

func (*CompressionType) PreParse 

func (p *CompressionType) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*CompressionType) Result 

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

func (*CompressionType) ResultAll 

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

func (*CompressionType) Set 

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

func (*CompressionType) SetPreComments 

func (p *CompressionType) SetPreComments(preComments []string)

type CompressionTypeReq 

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

func (*CompressionTypeReq) Delete 

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

func (*CompressionTypeReq) Get 

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

func (*CompressionTypeReq) GetOne 

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

func (*CompressionTypeReq) GetParserName 

func (p *CompressionTypeReq) GetParserName() string

func (*CompressionTypeReq) GetPreComments 

func (p *CompressionTypeReq) GetPreComments() ([]string, error)

func (*CompressionTypeReq) Init 

func (p *CompressionTypeReq) Init()

func (*CompressionTypeReq) Insert 

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

func (*CompressionTypeReq) Parse 

func (c *CompressionTypeReq) Parse(line string, parts []string, comment string) (string, error)

func (*CompressionTypeReq) PreParse 

func (p *CompressionTypeReq) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*CompressionTypeReq) Result 

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

func (*CompressionTypeReq) ResultAll 

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

func (*CompressionTypeReq) Set 

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

func (*CompressionTypeReq) SetPreComments 

func (p *CompressionTypeReq) SetPreComments(preComments []string)

type CompressionTypeRes 

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

func (*CompressionTypeRes) Delete 

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

func (*CompressionTypeRes) Get 

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

func (*CompressionTypeRes) GetOne 

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

func (*CompressionTypeRes) GetParserName 

func (p *CompressionTypeRes) GetParserName() string

func (*CompressionTypeRes) GetPreComments 

func (p *CompressionTypeRes) GetPreComments() ([]string, error)

func (*CompressionTypeRes) Init 

func (p *CompressionTypeRes) Init()

func (*CompressionTypeRes) Insert 

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

func (*CompressionTypeRes) Parse 

func (c *CompressionTypeRes) Parse(line string, parts []string, comment string) (string, error)

func (*CompressionTypeRes) PreParse 

func (p *CompressionTypeRes) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*CompressionTypeRes) Result 

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

func (*CompressionTypeRes) ResultAll 

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

func (*CompressionTypeRes) Set 

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

func (*CompressionTypeRes) SetPreComments 

func (p *CompressionTypeRes) SetPreComments(preComments []string)

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) GetPreComments 

func (p *ConfigSnippet) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*ConfigSnippet) PreParse 

func (p *ConfigSnippet) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*ConfigSnippet) SetPreComments 

func (p *ConfigSnippet) SetPreComments(preComments []string)
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) GetPreComments 

func (p *Cookie) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Cookie) PreParse 

func (p *Cookie) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Cookie) SetPreComments 

func (p *Cookie) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Daemon) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Daemon) PreParse 

func (p *Daemon) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Daemon) SetPreComments 

func (p *Daemon) SetPreComments(preComments []string)

type DeclareCapture 

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

func (*DeclareCapture) Delete 

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

func (*DeclareCapture) Get 

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

func (*DeclareCapture) GetOne 

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

func (*DeclareCapture) GetParserName 

func (p *DeclareCapture) GetParserName() string

func (*DeclareCapture) GetPreComments 

func (p *DeclareCapture) GetPreComments() ([]string, error)

func (*DeclareCapture) Init 

func (p *DeclareCapture) Init()

func (*DeclareCapture) Insert 

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

func (*DeclareCapture) Parse 

func (p *DeclareCapture) Parse(line string, parts []string, comment string) (string, error)

func (*DeclareCapture) PreParse 

func (p *DeclareCapture) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*DeclareCapture) Result 

func (dc *DeclareCapture) Result() ([]common.ReturnResultLine, error)

func (*DeclareCapture) ResultAll 

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

func (*DeclareCapture) Set 

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

func (*DeclareCapture) SetPreComments 

func (p *DeclareCapture) SetPreComments(preComments []string)

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) GetPreComments 

func (p *DefaultBackend) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*DefaultBackend) PreParse 

func (p *DefaultBackend) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*DefaultBackend) SetPreComments 

func (p *DefaultBackend) SetPreComments(preComments []string)

type DefaultBind 

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

func (*DefaultBind) Delete 

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

func (*DefaultBind) Get 

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

func (*DefaultBind) GetOne 

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

func (*DefaultBind) GetParserName 

func (p *DefaultBind) GetParserName() string

func (*DefaultBind) GetPreComments 

func (p *DefaultBind) GetPreComments() ([]string, error)

func (*DefaultBind) Init 

func (p *DefaultBind) Init()

func (*DefaultBind) Insert 

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

func (*DefaultBind) Parse 

func (d *DefaultBind) Parse(line string, parts []string, comment string) (string, error)

func (*DefaultBind) PreParse 

func (p *DefaultBind) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*DefaultBind) Result 

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

func (*DefaultBind) ResultAll 

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

func (*DefaultBind) Set 

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

func (*DefaultBind) SetPreComments 

func (p *DefaultBind) SetPreComments(preComments []string)

type DefaultPath 

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

func (*DefaultPath) Delete 

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

func (*DefaultPath) Get 

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

func (*DefaultPath) GetOne 

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

func (*DefaultPath) GetParserName 

func (p *DefaultPath) GetParserName() string

func (*DefaultPath) GetPreComments 

func (p *DefaultPath) GetPreComments() ([]string, error)

func (*DefaultPath) Init 

func (p *DefaultPath) Init()

func (*DefaultPath) Insert 

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

func (*DefaultPath) Parse 

func (d *DefaultPath) Parse(line string, parts []string, comment string) (string, error)

default-path { current | config | parent | origin <path> }

func (*DefaultPath) PreParse 

func (p *DefaultPath) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*DefaultPath) Result 

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

func (*DefaultPath) ResultAll 

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

func (*DefaultPath) Set 

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

func (*DefaultPath) SetPreComments 

func (p *DefaultPath) SetPreComments(preComments []string)

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) GetPreComments 

func (p *DefaultServer) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*DefaultServer) PreParse 

func (p *DefaultServer) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*DefaultServer) SetPreComments 

func (p *DefaultServer) SetPreComments(preComments []string)

type DgramBind 

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

func (*DgramBind) Delete 

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

func (*DgramBind) Get 

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

func (*DgramBind) GetOne 

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

func (*DgramBind) GetParserName 

func (p *DgramBind) GetParserName() string

func (*DgramBind) GetPreComments 

func (p *DgramBind) GetPreComments() ([]string, error)

func (*DgramBind) Init 

func (p *DgramBind) Init()

func (*DgramBind) Insert 

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

func (*DgramBind) Parse 

func (p *DgramBind) Parse(line string, parts []string, comment string) (string, error)

func (*DgramBind) PreParse 

func (p *DgramBind) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*DgramBind) Result 

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

func (*DgramBind) ResultAll 

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

func (*DgramBind) Set 

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

func (*DgramBind) SetPreComments 

func (p *DgramBind) SetPreComments(preComments []string)

type EmailAlert 

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

func (*EmailAlert) Delete 

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

func (*EmailAlert) Get 

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

func (*EmailAlert) GetOne 

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

func (*EmailAlert) GetParserName 

func (p *EmailAlert) GetParserName() string

func (*EmailAlert) GetPreComments 

func (p *EmailAlert) GetPreComments() ([]string, error)

func (*EmailAlert) Init 

func (p *EmailAlert) Init()

func (*EmailAlert) Insert 

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

func (*EmailAlert) Parse 

func (p *EmailAlert) Parse(line string, parts []string, comment string) (string, error)

func (*EmailAlert) PreParse 

func (p *EmailAlert) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*EmailAlert) Result 

func (e *EmailAlert) Result() ([]common.ReturnResultLine, error)

func (*EmailAlert) ResultAll 

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

func (*EmailAlert) Set 

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

func (*EmailAlert) SetPreComments 

func (p *EmailAlert) SetPreComments(preComments []string)

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) GetPreComments 

func (p *ErrorFile) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*ErrorFile) PreParse 

func (p *ErrorFile) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*ErrorFile) SetPreComments 

func (p *ErrorFile) SetPreComments(preComments []string)

type ErrorFiles 

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

func (*ErrorFiles) Delete 

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

func (*ErrorFiles) Get 

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

func (*ErrorFiles) GetOne 

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

func (*ErrorFiles) GetParserName 

func (p *ErrorFiles) GetParserName() string

func (*ErrorFiles) GetPreComments 

func (p *ErrorFiles) GetPreComments() ([]string, error)

func (*ErrorFiles) Init 

func (e *ErrorFiles) Init()

func (*ErrorFiles) Insert 

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

func (*ErrorFiles) Parse 

func (p *ErrorFiles) Parse(line string, parts []string, comment string) (string, error)

func (*ErrorFiles) PreParse 

func (p *ErrorFiles) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*ErrorFiles) Result 

func (e *ErrorFiles) Result() ([]common.ReturnResultLine, error)

func (*ErrorFiles) ResultAll 

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

func (*ErrorFiles) Set 

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

func (*ErrorFiles) SetPreComments 

func (p *ErrorFiles) SetPreComments(preComments []string)

type ErrorLoc302 

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

func (*ErrorLoc302) Delete 

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

func (*ErrorLoc302) Get 

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

func (*ErrorLoc302) GetOne 

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

func (*ErrorLoc302) GetParserName 

func (p *ErrorLoc302) GetParserName() string

func (*ErrorLoc302) GetPreComments 

func (p *ErrorLoc302) GetPreComments() ([]string, error)

func (*ErrorLoc302) Init 

func (p *ErrorLoc302) Init()

func (*ErrorLoc302) Insert 

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

func (*ErrorLoc302) Parse 

func (l *ErrorLoc302) Parse(line string, parts []string, comment string) (string, error)

func (*ErrorLoc302) PreParse 

func (p *ErrorLoc302) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*ErrorLoc302) Result 

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

func (*ErrorLoc302) ResultAll 

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

func (*ErrorLoc302) Set 

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

func (*ErrorLoc302) SetPreComments 

func (p *ErrorLoc302) SetPreComments(preComments []string)

type ErrorLoc303 

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

func (*ErrorLoc303) Delete 

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

func (*ErrorLoc303) Get 

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

func (*ErrorLoc303) GetOne 

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

func (*ErrorLoc303) GetParserName 

func (p *ErrorLoc303) GetParserName() string

func (*ErrorLoc303) GetPreComments 

func (p *ErrorLoc303) GetPreComments() ([]string, error)

func (*ErrorLoc303) Init 

func (p *ErrorLoc303) Init()

func (*ErrorLoc303) Insert 

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

func (*ErrorLoc303) Parse 

func (l *ErrorLoc303) Parse(line string, parts []string, comment string) (string, error)

func (*ErrorLoc303) PreParse 

func (p *ErrorLoc303) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*ErrorLoc303) Result 

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

func (*ErrorLoc303) ResultAll 

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

func (*ErrorLoc303) Set 

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

func (*ErrorLoc303) SetPreComments 

func (p *ErrorLoc303) SetPreComments(preComments []string)

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) GetPreComments 

func (p *ExternalCheck) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*ExternalCheck) PreParse 

func (p *ExternalCheck) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*ExternalCheck) SetPreComments 

func (p *ExternalCheck) SetPreComments(preComments []string)

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) GetPreComments 

func (p *ExternalCheckCommand) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

external-check command <command>

func (*ExternalCheckCommand) PreParse 

func (p *ExternalCheckCommand) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*ExternalCheckCommand) SetPreComments 

func (p *ExternalCheckCommand) SetPreComments(preComments []string)

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) GetPreComments 

func (p *ExternalCheckPath) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

external-check path <path>

func (*ExternalCheckPath) PreParse 

func (p *ExternalCheckPath) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*ExternalCheckPath) SetPreComments 

func (p *ExternalCheckPath) SetPreComments(preComments []string)

type ForcePersist 

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

func (*ForcePersist) Delete 

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

func (*ForcePersist) Get 

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

func (*ForcePersist) GetOne 

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

func (*ForcePersist) GetParserName 

func (p *ForcePersist) GetParserName() string

func (*ForcePersist) GetPreComments 

func (p *ForcePersist) GetPreComments() ([]string, error)

func (*ForcePersist) Init 

func (p *ForcePersist) Init()

func (*ForcePersist) Insert 

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

func (*ForcePersist) Parse 

func (p *ForcePersist) Parse(line string, parts []string, comment string) (string, error)

func (*ForcePersist) PreParse 

func (p *ForcePersist) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*ForcePersist) Result 

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

func (*ForcePersist) ResultAll 

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

func (*ForcePersist) Set 

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

func (*ForcePersist) SetPreComments 

func (p *ForcePersist) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Group) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Group) PreParse 

func (p *Group) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Group) SetPreComments 

func (p *Group) SetPreComments(preComments []string)

type H1CaseAdjust 

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

func (*H1CaseAdjust) Delete 

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

func (*H1CaseAdjust) Get 

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

func (*H1CaseAdjust) GetOne 

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

func (*H1CaseAdjust) GetParserName 

func (p *H1CaseAdjust) GetParserName() string

func (*H1CaseAdjust) GetPreComments 

func (p *H1CaseAdjust) GetPreComments() ([]string, error)

func (*H1CaseAdjust) Init 

func (p *H1CaseAdjust) Init()

func (*H1CaseAdjust) Insert 

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

func (*H1CaseAdjust) Parse 

func (p *H1CaseAdjust) Parse(line string, parts []string, comment string) (string, error)

func (*H1CaseAdjust) PreParse 

func (p *H1CaseAdjust) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*H1CaseAdjust) Result 

func (ca *H1CaseAdjust) Result() ([]common.ReturnResultLine, error)

func (*H1CaseAdjust) ResultAll 

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

func (*H1CaseAdjust) Set 

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

func (*H1CaseAdjust) SetPreComments 

func (p *H1CaseAdjust) SetPreComments(preComments []string)

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) GetPreComments 

func (p *HTTPCheckV2) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*HTTPCheckV2) PreParse 

func (p *HTTPCheckV2) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*HTTPCheckV2) SetPreComments 

func (p *HTTPCheckV2) SetPreComments(preComments []string)

type HTTPClientResolversPrefer 

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

func (*HTTPClientResolversPrefer) Delete 

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

func (*HTTPClientResolversPrefer) Get 

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

func (*HTTPClientResolversPrefer) GetOne 

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

func (*HTTPClientResolversPrefer) GetParserName 

func (p *HTTPClientResolversPrefer) GetParserName() string

func (*HTTPClientResolversPrefer) GetPreComments 

func (p *HTTPClientResolversPrefer) GetPreComments() ([]string, error)

func (*HTTPClientResolversPrefer) Init 

func (p *HTTPClientResolversPrefer) Init()

func (*HTTPClientResolversPrefer) Insert 

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

func (*HTTPClientResolversPrefer) Parse 

func (p *HTTPClientResolversPrefer) Parse(line string, parts []string, comment string) (string, error)

func (*HTTPClientResolversPrefer) PreParse 

func (p *HTTPClientResolversPrefer) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*HTTPClientResolversPrefer) Result 

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

func (*HTTPClientResolversPrefer) ResultAll 

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

func (*HTTPClientResolversPrefer) Set 

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

func (*HTTPClientResolversPrefer) SetPreComments 

func (p *HTTPClientResolversPrefer) SetPreComments(preComments []string)

type HTTPClientSSLVerify 

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

func (*HTTPClientSSLVerify) Delete 

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

func (*HTTPClientSSLVerify) Get 

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

func (*HTTPClientSSLVerify) GetOne 

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

func (*HTTPClientSSLVerify) GetParserName 

func (p *HTTPClientSSLVerify) GetParserName() string

func (*HTTPClientSSLVerify) GetPreComments 

func (p *HTTPClientSSLVerify) GetPreComments() ([]string, error)

func (*HTTPClientSSLVerify) Init 

func (p *HTTPClientSSLVerify) Init()

func (*HTTPClientSSLVerify) Insert 

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

func (*HTTPClientSSLVerify) Parse 

func (p *HTTPClientSSLVerify) Parse(line string, parts []string, comment string) (string, error)

func (*HTTPClientSSLVerify) PreParse 

func (p *HTTPClientSSLVerify) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*HTTPClientSSLVerify) Result 

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

func (*HTTPClientSSLVerify) ResultAll 

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

func (*HTTPClientSSLVerify) Set 

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

func (*HTTPClientSSLVerify) SetPreComments 

func (p *HTTPClientSSLVerify) SetPreComments(preComments []string)

type HTTPErrCodes 

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

func (*HTTPErrCodes) Delete 

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

func (*HTTPErrCodes) Get 

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

func (*HTTPErrCodes) GetOne 

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

func (*HTTPErrCodes) GetParserName 

func (p *HTTPErrCodes) GetParserName() string

func (*HTTPErrCodes) GetPreComments 

func (p *HTTPErrCodes) GetPreComments() ([]string, error)

func (*HTTPErrCodes) Init 

func (p *HTTPErrCodes) Init()

func (*HTTPErrCodes) Insert 

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

func (*HTTPErrCodes) Parse 

func (p *HTTPErrCodes) Parse(line string, parts []string, comment string) (string, error)

func (*HTTPErrCodes) PreParse 

func (p *HTTPErrCodes) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*HTTPErrCodes) Result 

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

func (*HTTPErrCodes) ResultAll 

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

func (*HTTPErrCodes) Set 

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

func (*HTTPErrCodes) SetPreComments 

func (p *HTTPErrCodes) SetPreComments(preComments []string)

type HTTPFailCodes 

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

func (*HTTPFailCodes) Delete 

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

func (*HTTPFailCodes) Get 

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

func (*HTTPFailCodes) GetOne 

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

func (*HTTPFailCodes) GetParserName 

func (p *HTTPFailCodes) GetParserName() string

func (*HTTPFailCodes) GetPreComments 

func (p *HTTPFailCodes) GetPreComments() ([]string, error)

func (*HTTPFailCodes) Init 

func (p *HTTPFailCodes) Init()

func (*HTTPFailCodes) Insert 

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

func (*HTTPFailCodes) Parse 

func (p *HTTPFailCodes) Parse(line string, parts []string, comment string) (string, error)

func (*HTTPFailCodes) PreParse 

func (p *HTTPFailCodes) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*HTTPFailCodes) Result 

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

func (*HTTPFailCodes) ResultAll 

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

func (*HTTPFailCodes) Set 

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

func (*HTTPFailCodes) SetPreComments 

func (p *HTTPFailCodes) SetPreComments(preComments []string)

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) GetPreComments 

func (p *HTTPReuse) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*HTTPReuse) PreParse 

func (p *HTTPReuse) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*HTTPReuse) SetPreComments 

func (p *HTTPReuse) SetPreComments(preComments []string)

type HTTPSendNameHeader 

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

func (*HTTPSendNameHeader) Delete 

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

func (*HTTPSendNameHeader) Get 

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

func (*HTTPSendNameHeader) GetOne 

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

func (*HTTPSendNameHeader) GetParserName 

func (p *HTTPSendNameHeader) GetParserName() string

func (*HTTPSendNameHeader) GetPreComments 

func (p *HTTPSendNameHeader) GetPreComments() ([]string, error)

func (*HTTPSendNameHeader) Init 

func (p *HTTPSendNameHeader) Init()

func (*HTTPSendNameHeader) Insert 

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

func (*HTTPSendNameHeader) Parse 

func (m *HTTPSendNameHeader) Parse(line string, parts []string, comment string) (string, error)

func (*HTTPSendNameHeader) PreParse 

func (p *HTTPSendNameHeader) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*HTTPSendNameHeader) Result 

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

func (*HTTPSendNameHeader) ResultAll 

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

func (*HTTPSendNameHeader) Set 

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

func (*HTTPSendNameHeader) SetPreComments 

func (p *HTTPSendNameHeader) SetPreComments(preComments []string)

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) GetPreComments 

func (p *HashType) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*HashType) PreParse 

func (p *HashType) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*HashType) SetPreComments 

func (p *HashType) SetPreComments(preComments []string)

type IgnorePersist 

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

func (*IgnorePersist) Delete 

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

func (*IgnorePersist) Get 

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

func (*IgnorePersist) GetOne 

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

func (*IgnorePersist) GetParserName 

func (p *IgnorePersist) GetParserName() string

func (*IgnorePersist) GetPreComments 

func (p *IgnorePersist) GetPreComments() ([]string, error)

func (*IgnorePersist) Init 

func (p *IgnorePersist) Init()

func (*IgnorePersist) Insert 

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

func (*IgnorePersist) Parse 

func (p *IgnorePersist) Parse(line string, parts []string, comment string) (string, error)

func (*IgnorePersist) PreParse 

func (p *IgnorePersist) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*IgnorePersist) Result 

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

func (*IgnorePersist) ResultAll 

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

func (*IgnorePersist) Set 

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

func (*IgnorePersist) SetPreComments 

func (p *IgnorePersist) SetPreComments(preComments []string)

type LoadCert 

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

func (*LoadCert) Delete 

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

func (*LoadCert) Get 

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

func (*LoadCert) GetOne 

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

func (*LoadCert) GetParserName 

func (p *LoadCert) GetParserName() string

func (*LoadCert) GetPreComments 

func (p *LoadCert) GetPreComments() ([]string, error)

func (*LoadCert) Init 

func (p *LoadCert) Init()

func (*LoadCert) Insert 

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

func (*LoadCert) Parse 

func (p *LoadCert) Parse(line string, parts []string, comment string) (string, error)

func (*LoadCert) PreParse 

func (p *LoadCert) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*LoadCert) Result 

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

func (*LoadCert) ResultAll 

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

func (*LoadCert) Set 

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

func (*LoadCert) SetPreComments 

func (p *LoadCert) SetPreComments(preComments []string)

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) GetPreComments 

func (p *LoadServerStateFromFile) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*LoadServerStateFromFile) PreParse 

func (p *LoadServerStateFromFile) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*LoadServerStateFromFile) SetPreComments 

func (p *LoadServerStateFromFile) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Log) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Log) PreParse 

func (p *Log) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Log) SetPreComments 

func (p *Log) SetPreComments(preComments []string)

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) GetPreComments 

func (p *LogSendHostName) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*LogSendHostName) PreParse 

func (p *LogSendHostName) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*LogSendHostName) SetPreComments 

func (p *LogSendHostName) SetPreComments(preComments []string)

type LogStdErr 

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

func (*LogStdErr) Delete 

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

func (*LogStdErr) Get 

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

func (*LogStdErr) GetOne 

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

func (*LogStdErr) GetParserName 

func (p *LogStdErr) GetParserName() string

func (*LogStdErr) GetPreComments 

func (p *LogStdErr) GetPreComments() ([]string, error)

func (*LogStdErr) Init 

func (p *LogStdErr) Init()

func (*LogStdErr) Insert 

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

func (*LogStdErr) Parse 

func (p *LogStdErr) Parse(line string, parts []string, comment string) (string, error)

func (*LogStdErr) PreParse 

func (p *LogStdErr) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*LogStdErr) Result 

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

func (*LogStdErr) ResultAll 

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

func (*LogStdErr) Set 

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

func (*LogStdErr) SetPreComments 

func (p *LogStdErr) SetPreComments(preComments []string)

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) GetPreComments 

func (p *LuaLoad) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*LuaLoad) PreParse 

func (p *LuaLoad) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*LuaLoad) SetPreComments 

func (p *LuaLoad) SetPreComments(preComments []string)

type LuaPrependPath 

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

func (*LuaPrependPath) Delete 

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

func (*LuaPrependPath) Get 

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

func (*LuaPrependPath) GetOne 

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

func (*LuaPrependPath) GetParserName 

func (p *LuaPrependPath) GetParserName() string

func (*LuaPrependPath) GetPreComments 

func (p *LuaPrependPath) GetPreComments() ([]string, error)

func (*LuaPrependPath) Init 

func (p *LuaPrependPath) Init()

func (*LuaPrependPath) Insert 

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

func (*LuaPrependPath) Parse 

func (p *LuaPrependPath) Parse(line string, parts []string, comment string) (string, error)

func (*LuaPrependPath) PreParse 

func (p *LuaPrependPath) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*LuaPrependPath) Result 

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

func (*LuaPrependPath) ResultAll 

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

func (*LuaPrependPath) Set 

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

func (*LuaPrependPath) SetPreComments 

func (p *LuaPrependPath) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Mailer) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Mailer) PreParse 

func (p *Mailer) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Mailer) SetPreComments 

func (p *Mailer) SetPreComments(preComments []string)

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) GetPreComments 

func (p *MasterWorker) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*MasterWorker) PreParse 

func (p *MasterWorker) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*MasterWorker) SetPreComments 

func (p *MasterWorker) SetPreComments(preComments []string)

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) GetPreComments 

func (p *MaxConn) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*MaxConn) PreParse 

func (p *MaxConn) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*MaxConn) SetPreComments 

func (p *MaxConn) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Mode) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Mode) PreParse 

func (p *Mode) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Mode) SetPreComments 

func (p *Mode) SetPreComments(preComments []string)

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) GetPreComments 

func (p *MonitorFail) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*MonitorFail) PreParse 

func (p *MonitorFail) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*MonitorFail) SetPreComments 

func (p *MonitorFail) SetPreComments(preComments []string)

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) GetPreComments 

func (p *MonitorURI) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*MonitorURI) PreParse 

func (p *MonitorURI) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*MonitorURI) SetPreComments 

func (p *MonitorURI) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Nameserver) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Nameserver) PreParse 

func (p *Nameserver) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Nameserver) SetPreComments 

func (p *Nameserver) SetPreComments(preComments []string)

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) GetPreComments 

func (p *NbProc) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*NbProc) PreParse 

func (p *NbProc) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*NbProc) SetPreComments 

func (p *NbProc) SetPreComments(preComments []string)

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) GetPreComments 

func (p *NbThread) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*NbThread) PreParse 

func (p *NbThread) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*NbThread) SetPreComments 

func (p *NbThread) SetPreComments(preComments []string)

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) GetPreComments 

func (p *NoSplice) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*NoSplice) PreParse 

func (p *NoSplice) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*NoSplice) SetPreComments 

func (p *NoSplice) SetPreComments(preComments []string)

type NumaCPUMapping 

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

func (*NumaCPUMapping) Delete 

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

func (*NumaCPUMapping) Get 

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

func (*NumaCPUMapping) GetOne 

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

func (*NumaCPUMapping) GetParserName 

func (p *NumaCPUMapping) GetParserName() string

func (*NumaCPUMapping) GetPreComments 

func (p *NumaCPUMapping) GetPreComments() ([]string, error)

func (*NumaCPUMapping) Init 

func (p *NumaCPUMapping) Init()

func (*NumaCPUMapping) Insert 

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

func (*NumaCPUMapping) Parse 

func (n *NumaCPUMapping) Parse(line string, parts []string, comment string) (string, error)

func (*NumaCPUMapping) PreParse 

func (p *NumaCPUMapping) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*NumaCPUMapping) Result 

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

func (*NumaCPUMapping) ResultAll 

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

func (*NumaCPUMapping) Set 

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

func (*NumaCPUMapping) SetPreComments 

func (p *NumaCPUMapping) SetPreComments(preComments []string)

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) GetPreComments 

func (p *OptionForwardFor) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

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

func (*OptionForwardFor) PreParse 

func (p *OptionForwardFor) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*OptionForwardFor) SetPreComments 

func (p *OptionForwardFor) SetPreComments(preComments []string)

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) GetPreComments 

func (p *OptionHTTPLog) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*OptionHTTPLog) PreParse 

func (p *OptionHTTPLog) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*OptionHTTPLog) SetPreComments 

func (p *OptionHTTPLog) SetPreComments(preComments []string)

type OptionHTTPRestrictReqHdrNames 

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

func (*OptionHTTPRestrictReqHdrNames) Delete 

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

func (*OptionHTTPRestrictReqHdrNames) Get 

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

func (*OptionHTTPRestrictReqHdrNames) GetOne 

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

func (*OptionHTTPRestrictReqHdrNames) GetParserName 

func (p *OptionHTTPRestrictReqHdrNames) GetParserName() string

func (*OptionHTTPRestrictReqHdrNames) GetPreComments 

func (p *OptionHTTPRestrictReqHdrNames) GetPreComments() ([]string, error)

func (*OptionHTTPRestrictReqHdrNames) Init 

func (p *OptionHTTPRestrictReqHdrNames) Init()

func (*OptionHTTPRestrictReqHdrNames) Insert 

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

func (*OptionHTTPRestrictReqHdrNames) Parse 

func (o *OptionHTTPRestrictReqHdrNames) Parse(line string, parts []string, comment string) (string, error)

func (*OptionHTTPRestrictReqHdrNames) PreParse 

func (p *OptionHTTPRestrictReqHdrNames) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*OptionHTTPRestrictReqHdrNames) Result 

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

func (*OptionHTTPRestrictReqHdrNames) ResultAll 

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

func (*OptionHTTPRestrictReqHdrNames) Set 

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

func (*OptionHTTPRestrictReqHdrNames) SetPreComments 

func (p *OptionHTTPRestrictReqHdrNames) SetPreComments(preComments []string)

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) GetPreComments 

func (p *OptionHttpchk) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

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

func (*OptionHttpchk) PreParse 

func (p *OptionHttpchk) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*OptionHttpchk) SetPreComments 

func (p *OptionHttpchk) SetPreComments(preComments []string)

type OptionMaxReqs 

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

func (*OptionMaxReqs) Delete 

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

func (*OptionMaxReqs) Get 

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

func (*OptionMaxReqs) GetOne 

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

func (*OptionMaxReqs) GetParserName 

func (p *OptionMaxReqs) GetParserName() string

func (*OptionMaxReqs) GetPreComments 

func (p *OptionMaxReqs) GetPreComments() ([]string, error)

func (*OptionMaxReqs) Init 

func (p *OptionMaxReqs) Init()

func (*OptionMaxReqs) Insert 

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

func (*OptionMaxReqs) Parse 

func (p *OptionMaxReqs) Parse(line string, parts []string, comment string) (string, error)

func (*OptionMaxReqs) PreParse 

func (p *OptionMaxReqs) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*OptionMaxReqs) Result 

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

func (*OptionMaxReqs) ResultAll 

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

func (*OptionMaxReqs) Set 

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

func (*OptionMaxReqs) SetPreComments 

func (p *OptionMaxReqs) SetPreComments(preComments []string)

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) GetPreComments 

func (p *OptionMysqlCheck) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

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

func (*OptionMysqlCheck) PreParse 

func (p *OptionMysqlCheck) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*OptionMysqlCheck) SetPreComments 

func (p *OptionMysqlCheck) SetPreComments(preComments []string)

type OptionOriginalTo 

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

func (*OptionOriginalTo) Delete 

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

func (*OptionOriginalTo) Get 

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

func (*OptionOriginalTo) GetOne 

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

func (*OptionOriginalTo) GetParserName 

func (p *OptionOriginalTo) GetParserName() string

func (*OptionOriginalTo) GetPreComments 

func (p *OptionOriginalTo) GetPreComments() ([]string, error)

func (*OptionOriginalTo) Init 

func (p *OptionOriginalTo) Init()

func (*OptionOriginalTo) Insert 

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

func (*OptionOriginalTo) Parse 

func (s *OptionOriginalTo) Parse(line string, parts []string, comment string) (string, error)

option originalto [ except <network> ] [ header <name> ]

func (*OptionOriginalTo) PreParse 

func (p *OptionOriginalTo) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*OptionOriginalTo) Result 

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

func (*OptionOriginalTo) ResultAll 

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

func (*OptionOriginalTo) Set 

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

func (*OptionOriginalTo) SetPreComments 

func (p *OptionOriginalTo) SetPreComments(preComments []string)

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) GetPreComments 

func (p *OptionPgsqlCheck) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

option pgsql-check [ user <username> ]

func (*OptionPgsqlCheck) PreParse 

func (p *OptionPgsqlCheck) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*OptionPgsqlCheck) SetPreComments 

func (p *OptionPgsqlCheck) SetPreComments(preComments []string)

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) GetPreComments 

func (p *OptionRedispatch) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

option redispatch <interval>

func (*OptionRedispatch) PreParse 

func (p *OptionRedispatch) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*OptionRedispatch) SetPreComments 

func (p *OptionRedispatch) SetPreComments(preComments []string)

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) GetPreComments 

func (p *OptionSmtpchk) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

option smtpchk <hello> <domain>

func (*OptionSmtpchk) PreParse 

func (p *OptionSmtpchk) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*OptionSmtpchk) SetPreComments 

func (p *OptionSmtpchk) SetPreComments(preComments []string)

type PassHeader 

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

func (*PassHeader) Delete 

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

func (*PassHeader) Get 

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

func (*PassHeader) GetOne 

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

func (*PassHeader) GetParserName 

func (p *PassHeader) GetParserName() string

func (*PassHeader) GetPreComments 

func (p *PassHeader) GetPreComments() ([]string, error)

func (*PassHeader) Init 

func (p *PassHeader) Init()

func (*PassHeader) Insert 

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

func (*PassHeader) Parse 

func (p *PassHeader) Parse(line string, parts []string, comment string) (string, error)

func (*PassHeader) PreParse 

func (p *PassHeader) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*PassHeader) Result 

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

func (*PassHeader) ResultAll 

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

func (*PassHeader) Set 

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

func (*PassHeader) SetPreComments 

func (p *PassHeader) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Peer) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Peer) PreParse 

func (p *Peer) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Peer) SetPreComments 

func (p *Peer) SetPreComments(preComments []string)

type Persist 

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

func (*Persist) Delete 

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

func (*Persist) Get 

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

func (*Persist) GetOne 

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

func (*Persist) GetParserName 

func (p *Persist) GetParserName() string

func (*Persist) GetPreComments 

func (p *Persist) GetPreComments() ([]string, error)

func (*Persist) Init 

func (p *Persist) Init()

func (*Persist) Insert 

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

func (*Persist) Parse 

func (p *Persist) Parse(line string, parts []string, comment string) (string, error)

func (*Persist) PreParse 

func (p *Persist) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*Persist) Result 

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

func (*Persist) ResultAll 

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

func (*Persist) Set 

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

func (*Persist) SetPreComments 

func (p *Persist) SetPreComments(preComments []string)

type ProcessVary 

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

func (*ProcessVary) Delete 

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

func (*ProcessVary) Get 

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

func (*ProcessVary) GetOne 

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

func (*ProcessVary) GetParserName 

func (p *ProcessVary) GetParserName() string

func (*ProcessVary) GetPreComments 

func (p *ProcessVary) GetPreComments() ([]string, error)

func (*ProcessVary) Init 

func (p *ProcessVary) Init()

func (*ProcessVary) Insert 

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

func (*ProcessVary) Parse 

func (p *ProcessVary) Parse(line string, parts []string, comment string) (string, error)

func (*ProcessVary) PreParse 

func (p *ProcessVary) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*ProcessVary) Result 

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

func (*ProcessVary) ResultAll 

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

func (*ProcessVary) Set 

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

func (*ProcessVary) SetPreComments 

func (p *ProcessVary) SetPreComments(preComments []string)

type QuicSocketOwner 

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

func (*QuicSocketOwner) Delete 

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

func (*QuicSocketOwner) Get 

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

func (*QuicSocketOwner) GetOne 

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

func (*QuicSocketOwner) GetParserName 

func (p *QuicSocketOwner) GetParserName() string

func (*QuicSocketOwner) GetPreComments 

func (p *QuicSocketOwner) GetPreComments() ([]string, error)

func (*QuicSocketOwner) Init 

func (p *QuicSocketOwner) Init()

func (*QuicSocketOwner) Insert 

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

func (*QuicSocketOwner) Parse 

func (p *QuicSocketOwner) Parse(line string, parts []string, comment string) (string, error)

func (*QuicSocketOwner) PreParse 

func (p *QuicSocketOwner) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*QuicSocketOwner) Result 

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

func (*QuicSocketOwner) ResultAll 

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

func (*QuicSocketOwner) Set 

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

func (*QuicSocketOwner) SetPreComments 

func (p *QuicSocketOwner) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Server) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Server) PreParse 

func (p *Server) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Server) SetPreComments 

func (p *Server) SetPreComments(preComments []string)

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) GetPreComments 

func (p *ServerTemplate) GetPreComments() ([]string, error)

func (*ServerTemplate) Init 

func (p *ServerTemplate) Init()

func (*ServerTemplate) Insert 

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

func (*ServerTemplate) Parse 

func (p *ServerTemplate) Parse(line string, parts []string, comment string) (string, error)

func (*ServerTemplate) PreParse 

func (p *ServerTemplate) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*ServerTemplate) SetPreComments 

func (p *ServerTemplate) SetPreComments(preComments []string)

type SetParam 

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

func (*SetParam) Delete 

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

func (*SetParam) Get 

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

func (*SetParam) GetOne 

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

func (*SetParam) GetParserName 

func (p *SetParam) GetParserName() string

func (*SetParam) GetPreComments 

func (p *SetParam) GetPreComments() ([]string, error)

func (*SetParam) Init 

func (p *SetParam) Init()

func (*SetParam) Insert 

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

func (*SetParam) Parse 

func (p *SetParam) Parse(line string, parts []string, comment string) (string, error)

func (*SetParam) PreParse 

func (p *SetParam) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*SetParam) Result 

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

func (*SetParam) ResultAll 

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

func (*SetParam) Set 

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

func (*SetParam) SetPreComments 

func (p *SetParam) SetPreComments(preComments []string)

type SetVar 

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

func (*SetVar) Delete 

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

func (*SetVar) Get 

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

func (*SetVar) GetOne 

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

func (*SetVar) GetParserName 

func (p *SetVar) GetParserName() string

func (*SetVar) GetPreComments 

func (p *SetVar) GetPreComments() ([]string, error)

func (*SetVar) Init 

func (p *SetVar) Init()

func (*SetVar) Insert 

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

func (*SetVar) Parse 

func (p *SetVar) Parse(line string, parts []string, comment string) (string, error)

func (*SetVar) PreParse 

func (p *SetVar) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*SetVar) Result 

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

func (*SetVar) ResultAll 

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

func (*SetVar) Set 

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

func (*SetVar) SetPreComments 

func (p *SetVar) SetPreComments(preComments []string)

type SetVarFmt 

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

func (*SetVarFmt) Delete 

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

func (*SetVarFmt) Get 

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

func (*SetVarFmt) GetOne 

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

func (*SetVarFmt) GetParserName 

func (p *SetVarFmt) GetParserName() string

func (*SetVarFmt) GetPreComments 

func (p *SetVarFmt) GetPreComments() ([]string, error)

func (*SetVarFmt) Init 

func (p *SetVarFmt) Init()

func (*SetVarFmt) Insert 

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

func (*SetVarFmt) Parse 

func (p *SetVarFmt) Parse(line string, parts []string, comment string) (string, error)

func (*SetVarFmt) PreParse 

func (p *SetVarFmt) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*SetVarFmt) Result 

func (t *SetVarFmt) Result() ([]common.ReturnResultLine, error)

func (*SetVarFmt) ResultAll 

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

func (*SetVarFmt) Set 

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

func (*SetVarFmt) SetPreComments 

func (p *SetVarFmt) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Socket) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Socket) PreParse 

func (p *Socket) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Socket) SetPreComments 

func (p *Socket) SetPreComments(preComments []string)

type Source 

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

func (*Source) Delete 

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

func (*Source) Get 

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

func (*Source) GetOne 

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

func (*Source) GetParserName 

func (p *Source) GetParserName() string

func (*Source) GetPreComments 

func (p *Source) GetPreComments() ([]string, error)

func (*Source) Init 

func (p *Source) Init()

func (*Source) Insert 

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

func (*Source) Parse 

func (s *Source) Parse(line string, parts []string, comment string) (string, error)

func (*Source) PreParse 

func (p *Source) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*Source) Result 

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

func (*Source) ResultAll 

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

func (*Source) Set 

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

func (*Source) SetPreComments 

func (p *Source) SetPreComments(preComments []string)

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) GetPreComments 

func (p *SslEngine) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*SslEngine) PreParse 

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

func (*SslEngine) Result 

func (s *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

func (*SslEngine) SetPreComments 

func (p *SslEngine) SetPreComments(preComments []string)

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) GetPreComments 

func (p *SslModeAsync) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*SslModeAsync) PreParse 

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

func (*SslModeAsync) Result 

func (p *SslModeAsync) Result() ([]common.ReturnResultLine, 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

func (*SslModeAsync) SetPreComments 

func (p *SslModeAsync) SetPreComments(preComments []string)

type StatsMaxconn 

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

func (*StatsMaxconn) Delete 

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

func (*StatsMaxconn) Get 

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

func (*StatsMaxconn) GetOne 

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

func (*StatsMaxconn) GetParserName 

func (p *StatsMaxconn) GetParserName() string

func (*StatsMaxconn) GetPreComments 

func (p *StatsMaxconn) GetPreComments() ([]string, error)

func (*StatsMaxconn) Init 

func (p *StatsMaxconn) Init()

func (*StatsMaxconn) Insert 

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

func (*StatsMaxconn) Parse 

func (s *StatsMaxconn) Parse(line string, parts []string, comment string) (string, error)

func (*StatsMaxconn) PreParse 

func (p *StatsMaxconn) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*StatsMaxconn) Result 

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

func (*StatsMaxconn) ResultAll 

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

func (*StatsMaxconn) Set 

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

func (*StatsMaxconn) SetPreComments 

func (p *StatsMaxconn) SetPreComments(preComments []string)

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) GetPreComments 

func (p *StatsTimeout) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*StatsTimeout) PreParse 

func (p *StatsTimeout) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*StatsTimeout) SetPreComments 

func (p *StatsTimeout) SetPreComments(preComments []string)

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) GetPreComments 

func (p *Stick) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*Stick) PreParse 

func (p *Stick) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*Stick) SetPreComments 

func (p *Stick) SetPreComments(preComments []string)

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) GetPreComments 

func (p *StickTable) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*StickTable) PreParse 

func (p *StickTable) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*StickTable) SetPreComments 

func (p *StickTable) SetPreComments(preComments []string)

type Table 

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

func (*Table) Delete 

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

func (*Table) Get 

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

func (*Table) GetOne 

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

func (*Table) GetParserName 

func (p *Table) GetParserName() string

func (*Table) GetPreComments 

func (p *Table) GetPreComments() ([]string, error)

func (*Table) Init 

func (p *Table) Init()

func (*Table) Insert 

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

func (*Table) Parse 

func (p *Table) Parse(line string, parts []string, comment string) (string, error)

func (*Table) PreParse 

func (p *Table) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*Table) Result 

func (t *Table) Result() ([]common.ReturnResultLine, error)

func (*Table) ResultAll 

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

func (*Table) Set 

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

func (*Table) SetPreComments 

func (p *Table) SetPreComments(preComments []string)

type ThreadGroup 

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

func (*ThreadGroup) Delete 

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

func (*ThreadGroup) Get 

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

func (*ThreadGroup) GetOne 

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

func (*ThreadGroup) GetParserName 

func (p *ThreadGroup) GetParserName() string

func (*ThreadGroup) GetPreComments 

func (p *ThreadGroup) GetPreComments() ([]string, error)

func (*ThreadGroup) Init 

func (p *ThreadGroup) Init()

func (*ThreadGroup) Insert 

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

func (*ThreadGroup) Parse 

func (p *ThreadGroup) Parse(line string, parts []string, comment string) (string, error)

func (*ThreadGroup) PreParse 

func (p *ThreadGroup) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*ThreadGroup) Result 

func (t *ThreadGroup) Result() ([]common.ReturnResultLine, error)

func (*ThreadGroup) ResultAll 

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

func (*ThreadGroup) Set 

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

func (*ThreadGroup) SetPreComments 

func (p *ThreadGroup) SetPreComments(preComments []string)

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) GetPreComments 

func (p *UniqueIDFormat) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*UniqueIDFormat) PreParse 

func (p *UniqueIDFormat) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*UniqueIDFormat) SetPreComments 

func (p *UniqueIDFormat) SetPreComments(preComments []string)

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) GetPreComments 

func (p *UniqueIDHeader) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*UniqueIDHeader) PreParse 

func (p *UniqueIDHeader) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*UniqueIDHeader) SetPreComments 

func (p *UniqueIDHeader) SetPreComments(preComments []string)

type UnixBind 

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

func (*UnixBind) Delete 

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

func (*UnixBind) Get 

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

func (*UnixBind) GetOne 

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

func (*UnixBind) GetParserName 

func (p *UnixBind) GetParserName() string

func (*UnixBind) GetPreComments 

func (p *UnixBind) GetPreComments() ([]string, error)

func (*UnixBind) Init 

func (p *UnixBind) Init()

func (*UnixBind) Insert 

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

func (*UnixBind) Parse 

func (p *UnixBind) Parse(line string, parts []string, comment string) (string, error)

func (*UnixBind) PreParse 

func (p *UnixBind) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*UnixBind) Result 

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

func (*UnixBind) ResultAll 

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

func (*UnixBind) Set 

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

func (*UnixBind) SetPreComments 

func (p *UnixBind) SetPreComments(preComments []string)

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) GetPreComments 

func (p *UseBackend) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*UseBackend) PreParse 

func (p *UseBackend) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*UseBackend) SetPreComments 

func (p *UseBackend) SetPreComments(preComments []string)

type UseFcgiApp 

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

func (*UseFcgiApp) Delete 

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

func (*UseFcgiApp) Get 

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

func (*UseFcgiApp) GetOne 

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

func (*UseFcgiApp) GetParserName 

func (p *UseFcgiApp) GetParserName() string

func (*UseFcgiApp) GetPreComments 

func (p *UseFcgiApp) GetPreComments() ([]string, error)

func (*UseFcgiApp) Init 

func (p *UseFcgiApp) Init()

func (*UseFcgiApp) Insert 

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

func (*UseFcgiApp) Parse 

func (s *UseFcgiApp) Parse(line string, parts []string, comment string) (string, error)

func (*UseFcgiApp) PreParse 

func (p *UseFcgiApp) PreParse(line string, parts []string, preComments []string, comment string) (string, error)

func (*UseFcgiApp) Result 

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

func (*UseFcgiApp) ResultAll 

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

func (*UseFcgiApp) Set 

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

func (*UseFcgiApp) SetPreComments 

func (p *UseFcgiApp) SetPreComments(preComments []string)

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) GetPreComments 

func (p *UseServer) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*UseServer) PreParse 

func (p *UseServer) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*UseServer) SetPreComments 

func (p *UseServer) SetPreComments(preComments []string)

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) GetPreComments 

func (p *User) GetPreComments() ([]string, error)

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 []string, comment string) (string, error)

func (*User) PreParse 

func (p *User) PreParse(line string, parts []string, preComments []string, comment string) (string, 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

func (*User) SetPreComments 

func (p *User) SetPreComments(preComments []string)

Source Files

View all Source files

Directories

Path Synopsis
Code generated by go generate; DO NOT EDIT.
 Code generated by go generate; DO NOT EDIT.
Code generated by go generate; DO NOT EDIT.
 Code generated by go generate; DO NOT EDIT.
Code generated by go generate; DO NOT EDIT.
 Code generated by go generate; DO NOT EDIT.
actions
Code generated by go generate; DO NOT EDIT.
 Code generated by go generate; DO NOT EDIT.
settings
tcp
Code generated by go generate; DO NOT EDIT.
 Code generated by go generate; DO NOT EDIT.
actions
types

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.