// --------- This code has been automatically generated !!! 2018-09-03T20:28:07.604Z
"use strict";
/**
 * @module opcua.address_space.types
 */
const assert = require("node-opcua-assert").assert;
const util = require("util");
const _  = require("underscore");
const makeNodeId = require("node-opcua-nodeid").makeNodeId;
const schema_helpers =  require("node-opcua-factory/src/factories_schema_helpers");
const extract_all_fields                       = schema_helpers.extract_all_fields;
const resolve_schema_field_types               = schema_helpers.resolve_schema_field_types;
const initialize_field                         = schema_helpers.initialize_field;
const initialize_field_array                   = schema_helpers.initialize_field_array;
const check_options_correctness_against_schema = schema_helpers.check_options_correctness_against_schema;
const _defaultTypeMap = require("node-opcua-factory/src/factories_builtin_types")._defaultTypeMap;
const ec = require("node-opcua-basic-types");
const encodeArray = ec.encodeArray;
const decodeArray = ec.decodeArray;
const makeExpandedNodeId = require("node-opcua-nodeid/src/expanded_nodeid").makeExpandedNodeId;
const generate_new_id = require("node-opcua-factory").generate_new_id;
const _enumerations = require("node-opcua-factory/src/factories_enumerations")._private._enumerations;
const schema = require("../schemas/FindServersOnNetworkRequest_schema").FindServersOnNetworkRequest_Schema;
const getFactory = require("node-opcua-factory/src/factories_factories").getFactory;
const RequestHeader = getFactory("RequestHeader");
const BaseUAObject = require("node-opcua-factory/src/factories_baseobject").BaseUAObject;

/**
 * Finds the servers known to the discovery server.
 * 
 * @class FindServersOnNetworkRequest
 * @constructor
 * @extends BaseUAObject
 * @param  options {Object}
 */
function FindServersOnNetworkRequest(options)
{
    options = options || {};
    /* istanbul ignore next */
    if (schema_helpers.doDebug) { check_options_correctness_against_schema(this,schema,options); }
    const self = this;
    assert(this instanceof BaseUAObject); //  ' keyword "new" is required for constructor call')
    resolve_schema_field_types(schema);

    BaseUAObject.call(this,options);
    if (options === null) { 
        BaseUAObject.call(this,options);
        self.requestHeader =  null; /* new RequestHeader(null); */
        return ;
    }

    /**
      * A standard header included in all requests sent to a server.
      * @property requestHeader
      * @type {RequestHeader}
      */
    self.requestHeader =  new RequestHeader( options.requestHeader);

    /**
      * Only records with an identifier greater than this number will be returned. Specify 0 to start with the first record in the cache.
      * @property startingRecordId
      * @type {Counter}
      */
    self.startingRecordId = initialize_field(schema.fields[1], options.startingRecordId);

    /**
      * The maximum number of records to return in the response.
0 indicates that there is no limit.
      * @property maxRecordsToReturn
      * @type {UInt32}
      */
    self.maxRecordsToReturn = initialize_field(schema.fields[2], options.maxRecordsToReturn);

    /**
      * List of Server capability filters. The set of allowed server capabilities
are defined in Part 12.
Only records with all of the specified server capabilities are
returned.
The comparison is case insensitive.
If this list is empty then no filtering is performed.
      * @property serverCapabilityFilter
      * @type {String[]}
      */
    self.serverCapabilityFilter = initialize_field_array(schema.fields[3], options.serverCapabilityFilter);

   // Object.preventExtensions(self);
}
util.inherits(FindServersOnNetworkRequest,BaseUAObject);
FindServersOnNetworkRequest.prototype.encodingDefaultBinary = makeExpandedNodeId(12208,0);
FindServersOnNetworkRequest.prototype.encodingDefaultXml = makeExpandedNodeId(12196,0);
FindServersOnNetworkRequest.prototype._schema = schema;

const encode_Counter = _defaultTypeMap.Counter.encode;
const decode_Counter = _defaultTypeMap.Counter.decode;
const encode_UInt32 = _defaultTypeMap.UInt32.encode;
const decode_UInt32 = _defaultTypeMap.UInt32.decode;
const encode_String = _defaultTypeMap.String.encode;
const decode_String = _defaultTypeMap.String.decode;
/**
 * encode the object into a binary stream
 * @method encode
 *
 * @param stream {BinaryStream} 
 */
FindServersOnNetworkRequest.prototype.encode = function(stream,options) {
    // call base class implementation first
    BaseUAObject.prototype.encode.call(this,stream,options);
   this.requestHeader.encode(stream,options);
    encode_Counter(this.startingRecordId,stream);
    encode_UInt32(this.maxRecordsToReturn,stream);
    encodeArray(this.serverCapabilityFilter, stream, encode_String);
};
/**
 * decode the object from a binary stream
 * @method decode
 *
 * @param stream {BinaryStream} 
 */
FindServersOnNetworkRequest.prototype.decode = function(stream) {
    // call base class implementation first
    BaseUAObject.prototype.decode.call(this,stream);
    this.requestHeader.decode(stream);
    this.startingRecordId = decode_Counter(stream);
    this.maxRecordsToReturn = decode_UInt32(stream);
    this.serverCapabilityFilter = decodeArray(stream, decode_String);
};
FindServersOnNetworkRequest.possibleFields = [
  "requestHeader",
         "startingRecordId",
         "maxRecordsToReturn",
         "serverCapabilityFilter"
];


exports.FindServersOnNetworkRequest = FindServersOnNetworkRequest;
const register_class_definition = require("node-opcua-factory/src/factories_factories").register_class_definition;
register_class_definition("FindServersOnNetworkRequest",FindServersOnNetworkRequest);