Example #1
0
		private void AssertNodeValues (
			XmlReader xmlReader,
			XmlNodeType nodeType,
			int depth,
			bool isEmptyElement,
			string name,
			string prefix,
			string localName,
			string namespaceURI,
			string value,
			int attributeCount)
		{
			Assert.AreEqual (nodeType, xmlReader.NodeType, "NodeType");
			Assert.AreEqual (depth, xmlReader.Depth, "Depth");
			Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, "IsEmptyElement");

			Assert.AreEqual (name, xmlReader.Name, "name");

			Assert.AreEqual (prefix, xmlReader.Prefix, "prefix");

			Assert.AreEqual (localName, xmlReader.LocalName, "localName");

			Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, "namespaceURI");

			Assert.AreEqual ((value != String.Empty), xmlReader.HasValue, "hasValue");

			Assert.AreEqual (value, xmlReader.Value, "Value");

			Assert.AreEqual (attributeCount > 0, xmlReader.HasAttributes, "hasAttributes");

			Assert.AreEqual (attributeCount, xmlReader.AttributeCount, "attributeCount");
		}
        private static string GetMemberElement(
            FunctionDescriptor function,
            XmlReader xml,
            DocumentElementType property,
            string paramName = "")
        {
            //customNodeDefinitions typedParameters don't have functionDescriptors
            if (function == null)
            {
                return string.Empty;
            }
            var assemblyName = function.Assembly;

            if (string.IsNullOrEmpty(assemblyName))
                return String.Empty;

            var fullyQualifiedName = MemberDocumentNode.MakeFullyQualifiedName
                (assemblyName, GetMemberElementName(function));

            if (!documentNodes.ContainsKey(fullyQualifiedName))
            {
                if (xml == null)
                    xml = DocumentationServices.GetForAssembly(function.Assembly, function.PathManager);
                LoadDataFromXml(xml, assemblyName);
            }

            MemberDocumentNode documentNode = null;
            if (documentNodes.ContainsKey(fullyQualifiedName))
                documentNode = documentNodes[fullyQualifiedName];
            else
            {
                var overloadedName = documentNodes.Keys.
                        Where(key => key.Contains(function.ClassName + "." + function.FunctionName)).FirstOrDefault();

                if (overloadedName == null)
                    return String.Empty;
                if (documentNodes.ContainsKey(overloadedName))
                    documentNode = documentNodes[overloadedName];
            }
            
            if (documentNode == null)
                return String.Empty;
            if (property.Equals(DocumentElementType.Description) && !documentNode.Parameters.ContainsKey(paramName))
                return String.Empty;

            switch (property)
            {
                case DocumentElementType.Summary:
                    return documentNode.Summary;

                case DocumentElementType.Description:
                    return documentNode.Parameters[paramName];

                case DocumentElementType.SearchTags:
                    return documentNode.SearchTags;

                default:
                    throw new ArgumentException("property");
            }
        }
        private void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                int itemsCount = 7;
                xmlReader = XmlReader.Create(new StringReader(e.Result));
                feed = SyndicationFeed.Load(xmlReader);

                List<RSSItem> itemsList = new List<RSSItem>();

                if (feed.Items.Count() < 7)
                {
                    itemsCount = feed.Items.Count();
                }

                for (int i = 0; i <= itemsCount; i++)
                {
                    RSSItem rssitem = new RSSItem();
                    rssitem.RSSTitle = feed.Items.ToList()[i].Title.Text;
                    rssitem.RSSLink = feed.Items.ToList()[i].Links[0].Uri;
                    itemsList.Add(rssitem);
                }
                RSS.ItemsSource = itemsList;
            }
        }
Example #4
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="xml">XML to validate</param>
        /// <param name="schemaUri">Schema Uri</param>
        public DnaXmlValidator(string xml, string schemaUri)
        {
            _schemaUri = schemaUri;
            // set up the schema
            LoadSchema(schemaUri);

            // set up the xml reader
            _rawXml = xml;
            _xml = new StringReader(xml);

            // set up the settings for validating the xml
            _validationSettings = new XmlReaderSettings();
            _validationSettings.Schemas.Add(_xmlSchema);
            _validationSettings.IgnoreWhitespace = true;
            _validationSettings.ValidationFlags |= XmlSchemaValidationFlags.ProcessSchemaLocation;
            _validationSettings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
            _validationSettings.ValidationFlags |= XmlSchemaValidationFlags.ProcessInlineSchema;
            _validationSettings.ValidationType = ValidationType.Schema;
            try
            {
                _validationSettings.Schemas.Compile();
            }
            catch (XmlSchemaException e)
            {
                string s = e.SourceUri;
            }
            _validationSettings.ValidationEventHandler += new ValidationEventHandler(xmlReaderSettingsValidationEventHandler);
            _validationSettings.DtdProcessing = DtdProcessing.Parse;
            // set the the XmlReader for validation
            _validator = XmlReader.Create(_xml, _validationSettings);
        }
		public override bool CanRead (XmlReader reader)
		{
			if (reader == null)
				throw new ArgumentNullException ("reader");
			reader.MoveToContent ();
			return reader.LocalName == "service" && reader.NamespaceURI == Version;
		}
Example #6
0
 void createPlayer(XmlReader reader)
 {
     Vector2 pos = Vector2.Zero;
     TextureMap t = new TextureMap();
     while (reader.Read())
     {
         if (reader.NodeType == XmlNodeType.Element)
         {
             switch (reader.Name)
             {
                 case "position":
                     {
                         reader.ReadToDescendant("x");
                         float x = (float)float.Parse((reader.GetAttribute(0)));
                         reader.ReadToNextSibling("y");
                         float y = (float)float.Parse((reader.GetAttribute(0)));
                         pos = new Vector2(x, y);
                     }
                     break;
                 default:
                     int o = 0;//fer teh deboog
                     break;
             }
         }
     }
     Player p = new Player(pos, t);
 }
Example #7
0
		// copy from XmlTextReaderTests
		private void AssertStartDocument (XmlReader xmlReader)
		{
			Assert.IsTrue (xmlReader.ReadState == ReadState.Initial);
			Assert.IsTrue (xmlReader.NodeType == XmlNodeType.None);
			Assert.IsTrue (xmlReader.Depth == 0);
			Assert.IsTrue (!xmlReader.EOF);
		}
		private void AssertNodeValues (
			XmlReader xmlReader,
			XmlNodeType nodeType,
			int depth,
			bool isEmptyElement,
			string name,
			string prefix,
			string localName,
			string namespaceURI,
			string value,
			int attributeCount)
		{
			AssertEquals ("NodeType", nodeType, xmlReader.NodeType);
			AssertEquals ("Depth", depth, xmlReader.Depth);
			AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);

			AssertEquals ("name", name, xmlReader.Name);

			AssertEquals ("prefix", prefix, xmlReader.Prefix);

			AssertEquals ("localName", localName, xmlReader.LocalName);

			AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI);

			AssertEquals ("hasValue", (value != String.Empty), xmlReader.HasValue);

			AssertEquals ("Value", value, xmlReader.Value);

			AssertEquals ("hasAttributes", attributeCount > 0, xmlReader.HasAttributes);

			AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount);
		}
Example #9
0
        public static bool ValidateXml(XmlReader reader, string customSchema, Action<string> warning, Action<string> error)
        {
            bool isValid = true;

            var schemas = GetSchemas();

            if (customSchema != null)
            {
                schemas.Add(null, XmlReader.Create(customSchema));
            }

            ValidationEventHandler handler = (s, args) =>
            {
                isValid = false;
                if (warning != null && args.Severity == XmlSeverityType.Warning)
                    warning(args.Message);
                else if (error != null)
                    error(args.Message);
            };

            var settings = new XmlReaderSettings();
            settings.ValidationType = ValidationType.Schema;
            settings.Schemas.Add(schemas);
            settings.ValidationEventHandler += handler;

            var r = XmlReader.Create(reader, settings);
            while (r.Read()) ;

            return isValid;
        }
Example #10
0
        private ClientData(XmlReader reader)
        {
            reader.ReadStartElement("ClientData");

            for (int iter = 0; iter < _NumStoredValues; iter++) {

                reader.ReadStartElement(_StoredValueNames[iter]);

                if (_StoredValues[iter] is string)
                    _StoredValues[iter] = reader.ReadContentAsString();
                else if (_StoredValues[iter] is DateTime) {
                    string s = reader.ReadContentAsString();
                    long l = long.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
                    _StoredValues[iter] = DateTime.FromFileTimeUtc(l);
                } else if (_StoredValues[iter] is bool) {
                    string s = reader.ReadContentAsString();
                    _StoredValues[iter] = !(string.IsNullOrEmpty(s) || s != "1");
                } else {
                    _StoredValues[iter] = ReadStringArray(reader);
                }
                reader.ReadEndElement();
            }

            reader.ReadEndElement();
        }
		public void LoadFromXml (XmlReader reader)
		{
			reader.ReadToDescendant ("plist");
			while (reader.Read () && reader.NodeType != XmlNodeType.Element);
			if (!reader.EOF)
				root = LoadFromNode (reader);
		}
        /// <summary>tries to parse a category collection document</summary> 
        /// <param name="reader"> xmlReader positioned at the start element</param>
        /// <param name="owner">the base object that the collection belongs to</param>
        /// <returns></returns>
        public AtomCategoryCollection ParseCategories(XmlReader reader, AtomBase owner) {
            Tracing.Assert(reader != null, "reader should not be null");
            if (reader == null) {
                throw new ArgumentNullException("reader");
            }
            AtomCategoryCollection ret = new AtomCategoryCollection();
            MoveToStartElement(reader);

            Tracing.TraceCall("entering Categories Parser");
            object localname = reader.LocalName;
            Tracing.TraceInfo("localname is: " + reader.LocalName);

            if (IsCurrentNameSpace(reader, BaseNameTable.AppPublishingNamespace(owner)) &&
                localname.Equals(this.nameTable.Categories)) {
                Tracing.TraceInfo("Found categories  document");
                int depth = -1;
                while (NextChildElement(reader, ref depth)) {
                    localname = reader.LocalName;
                    if (IsCurrentNameSpace(reader, BaseNameTable.NSAtom)) {
                        if (localname.Equals(this.nameTable.Category)) {
                            AtomCategory category = ParseCategory(reader, owner);
                            ret.Add(category);
                        }
                    }
                }
            } else {
                Tracing.TraceInfo("ParseCategories called and nothing was parsed" + localname);
                throw new ClientFeedException("An invalid Atom Document was passed to the parser. This was not an app:categories document: " + localname);
            }

            return ret;
        }
Example #13
0
 private static string GenerateCode(XmlReader reader, string nameSpace)
 {
     EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode) {
         Version = DataServiceCodeVersion.V2
     };
     StringWriter targetWriter = new StringWriter();
     try
     {
         IList<EdmSchemaError> list = generator.GenerateCode(reader, targetWriter, nameSpace);
         if (list.Count > 0)
         {
             throw new DisplayToUserException(string.Concat(new object[] { "Bad schema: ", list[0].Message, " (line ", list[0].Line, ")" }));
         }
     }
     catch (MetadataException exception)
     {
         throw new DisplayToUserException("MetadataException: " + exception.Message);
     }
     catch (XmlSchemaValidationException exception2)
     {
         throw new DisplayToUserException("This schema is unsupported.\r\n\r\nEntityClassGenerator returned the following error: " + exception2.Message);
     }
     catch (FileNotFoundException exception3)
     {
         if (exception3.Message.Contains("System.Data.Services.Design"))
         {
             throw new DisplayToUserException("Cannot load System.Data.Services.Design.dll. (A possible cause is installing only the .NET Framework Client Profile instead of the full .NET Framework.)");
         }
         throw;
     }
     return targetWriter.ToString();
 }
 public XmlRpcResponse DeserializeResponse(XmlReader rdr, Type returnType)
 {
     try
     {
         IEnumerator<Node> enumerator = new XmlRpcParser().ParseResponse(rdr).GetEnumerator();
         enumerator.MoveNext();
         if (enumerator.Current is FaultNode)
             throw DeserializeFault(enumerator);
         if (returnType == typeof (void) || !enumerator.MoveNext())
         {
             return new XmlRpcResponse
                    {
                        retVal = null
                    };
         }
         Node current = enumerator.Current;
         object obj = MapValueNode(enumerator, returnType, new MappingStack("response"), MappingAction.Error);
         return new XmlRpcResponse
                {
                    retVal = obj
                };
     }
     catch (XmlException ex)
     {
         throw new XmlRpcIllFormedXmlException("Response contains invalid XML", ex);
     }
 }
 protected override void DeserializeElement(XmlReader reader, bool serializeCollectionKey)
 {
     base.DeserializeElement(reader, serializeCollectionKey);
     WebContext hostingContext = base.EvaluationContext.HostingContext as WebContext;
     if ((hostingContext != null) && (this.Href.Length != 0))
     {
         string path = hostingContext.Path;
         string configurationDirectory = null;
         if (path == null)
         {
             path = HostingEnvironment.ApplicationVirtualPath;
             if (path == null)
             {
                 path = "";
             }
             configurationDirectory = this.GetConfigurationDirectory();
         }
         else
         {
             configurationDirectory = HostingEnvironment.MapPath(path);
         }
         if (!path.EndsWith("/", StringComparison.Ordinal))
         {
             path = path + "/";
         }
         CheckIOReadPermission(configurationDirectory, this.Href);
         this.actualPath = configurationDirectory;
         this.virtualPath = path;
         this.needToValidateHref = true;
     }
 }
Example #16
0
 public static XmlReader CreateReader(XmlReader baseReader, WhitespaceRuleLookup wsRules)
 {
     if (wsRules == null)
     {
         return baseReader;    // There is no rules to process
     }
     XmlReaderSettings readerSettings = baseReader.Settings;
     if (readerSettings != null)
     {
         if (readerSettings.IgnoreWhitespace)
         {
             return baseReader;        // V2 XmlReader that strips all WS
         }
     }
     else
     {
         XmlTextReader txtReader = baseReader as XmlTextReader;
         if (txtReader != null && txtReader.WhitespaceHandling == WhitespaceHandling.None)
         {
             return baseReader;        // V1 XmlTextReader that strips all WS
         }
         XmlTextReaderImpl txtReaderImpl = baseReader as XmlTextReaderImpl;
         if (txtReaderImpl != null && txtReaderImpl.WhitespaceHandling == WhitespaceHandling.None)
         {
             return baseReader;        // XmlTextReaderImpl that strips all WS
         }
     }
     return new WhitespaceRuleReader(baseReader, wsRules);
 }
Example #17
0
 internal InternalDeserializer(XmlReader reader, DeserializationContext context)
 {
     this._reader = reader;
     this._context = context;
     this.objectRefIdHandler = new ReferenceIdHandlerForDeserializer<object>();
     this.typeRefIdHandler = new ReferenceIdHandlerForDeserializer<ConsolidatedString>();
 }
 public static WebReferenceOptions Read(XmlReader xmlReader, ValidationEventHandler validationEventHandler)
 {
     WebReferenceOptions options;
     XmlValidatingReader reader = new XmlValidatingReader(xmlReader) {
         ValidationType = ValidationType.Schema
     };
     if (validationEventHandler != null)
     {
         reader.ValidationEventHandler += validationEventHandler;
     }
     else
     {
         reader.ValidationEventHandler += new ValidationEventHandler(WebReferenceOptions.SchemaValidationHandler);
     }
     reader.Schemas.Add(Schema);
     webReferenceOptionsSerializer serializer = new webReferenceOptionsSerializer();
     try
     {
         options = (WebReferenceOptions) serializer.Deserialize(reader);
     }
     catch (Exception exception)
     {
         throw exception;
     }
     finally
     {
         reader.Close();
     }
     return options;
 }
Example #19
0
 /// <summary>Initializes a new instance of the XmlConfigFile
 /// class.</summary>
 /// <param name='reader'>A XmlReader object.</param>
 /// <param name='rootElement'>A string object.</param>
 /// <exception cref='ArgumentNullException'>The parameter <paramref
 /// name='reader'/> is null.</exception>
 private XmlConfigFile(XmlReader reader, string rootElement)
 {
     if (reader == null) {
     throw new ArgumentNullException("reader");
       }
       if (rootElement.Length == 0) {
     throw new ArgumentException("'rootElement' is empty.");
       }
       XmlDocument doc;
       try {
     doc = new XmlDocument();
     doc.Load(reader);
       } catch (IOException e) {
     throw new XmlConfigException(e.Message, e);
       } catch (UnauthorizedAccessException e) {
     throw new XmlConfigException(e.Message, e);
       } catch (XmlException e) {
     throw new XmlConfigException(e.Message, e);
       }
       if (doc.DocumentElement == null) {
     throw new XmlConfigException("The file contains no XML element.");
       }
       if (rootElement != null && !doc.DocumentElement.Name.Equals(rootElement))
     throw new XmlConfigException(
       ("The XML file's root element is " + doc.DocumentElement.Name +
     ", not " + rootElement + "."));
       this.Initialize(doc.DocumentElement);
 }
Example #20
0
 public MappingOption(XmlReader xml)
 {
     Schema = xml.GetAttribute("Schema");
     Prefix = xml.GetAttribute("Prefix");
     Class = xml.GetAttribute("Class");
     Pattern = xml.GetAttribute("Pattern");
 }
Example #21
0
        // TwoWayRequest: Accept two integer values, return their sum
        public byte[] TwoWayRequest(WsWsaHeader header, XmlReader reader)
        {
            try
            {
                // Find beginning of request
                reader.ReadStartElement("TwoWayRequest", SimpleServiceNamespaceUri);

                // Find the values to be added
                int X = Convert.ToInt32(reader.ReadElementString("X", SimpleServiceNamespaceUri));
                int Y = Convert.ToInt32(reader.ReadElementString("Y", SimpleServiceNamespaceUri));

                Log.Comment("");
                Log.Comment("X = " + X.ToString() + " Y = " + Y.ToString());
                Log.Comment(X.ToString() + " + " + Y.ToString() + " = " + ((int)(X + Y)).ToString());
                Log.Comment("");

                // Return the response
                return TwoWayResponse(header, X + Y);
            }
            catch (Exception e)
            {
                // Something went wrong 
                throw new WsFaultException(header, WsFaultType.XmlException, e.ToString());
            }
        }
        public override void ReadXml(XmlReader reader)
        {
            complexParameters.Clear();
            primitiveParameters.Clear();

            reader.MoveToContent();

            reader.ReadStartElement();

            primitiveParameters.Add("Regions", reader.ReadElementContentAsDouble());
            primitiveParameters.Add("PointsPerRegion", reader.ReadElementContentAsDouble());

            reader.MoveToFirstAttribute();

            int cnt = Int32.Parse(reader.GetAttribute("Count"));
            reader.ReadToFollowing("Requirement");
            IList<string> requirements = new List<string>();

            for (int i = 0; i < cnt; i++)
            {
                requirements.Add(reader.ReadElementContentAsString());
            }

            complexParameters.Add("Requirements", requirements);

            reader.ReadEndElement();

            primitiveParameters.Add("UseAdaptiveRandomSearch", reader.ReadElementContentAsBoolean());
            primitiveParameters.Add("OptimizationAlgorithm", reader.ReadElementContentAsString());
            reader.ReadEndElement();
        }
Example #23
0
        /// <summary>
        /// Decodes an <see cref="Error"/> object from its XML representation.
        /// </summary>
        public static Error Decode(XmlReader reader)
        {
            if (reader == null) throw new ArgumentNullException("reader");
            if (!reader.IsStartElement()) throw new ArgumentException("Reader is not positioned at the start of an element.", "reader");

            //
            // Read out the attributes that contain the simple
            // typed state.
            //

            var error = new Error();
            ReadXmlAttributes(reader, error);

            //
            // Move past the element. If it's not empty, then
            // read also the inner XML that contains complex
            // types like collections.
            //

            var isEmpty = reader.IsEmptyElement;
            reader.Read();

            if (!isEmpty)
            {
                ReadInnerXml(reader, error);
                reader.ReadEndElement();
            }

            return error;
        }
Example #24
0
 public static XmlDocument IsWellFormed(XmlReader reader)
 {
     Assert.IsNotNull(reader);
     XmlDocument doc = new XmlDocument();
     doc.Load(reader);
     return doc;
 }
 /// <param name="xml">Don't set it, it's just for tests.</param>
 public static IEnumerable<string> GetSearchTags(this FunctionDescriptor member, XmlReader xml = null)
 {
     return GetMemberElement(member, xml, DocumentElementType.SearchTags)
         .Split(',')
         .Select(x => x.Trim())
         .Where(x => x != String.Empty);
 }
Example #26
0
        public static void TransformNode(XmlNode element, XmlReader xslTemplate)
        {
            XmlReader reader = new XmlNodeReader(element);

              XmlReader transformResultReader = TransformXml(reader, xslTemplate, null);
              element.CreateNavigator().ReplaceSelf(transformResultReader);
        }
Example #27
0
    public override void gaxb_load(XmlReader reader, object _parent, Hashtable args)
    {
        base.gaxb_load(reader, _parent, args);

        if (nameExists && titleExists == false) {
            gameObject.name = name;
        }

        var prefab = Resources.Load (name);
        if (prefab == null) {
            UnityEngine.Debug.Log ("Unable to load prefab resource " + name);
            return;
        }
        GameObject clone = GameObject.Instantiate(prefab) as GameObject;
        if (clone == null) {
            UnityEngine.Debug.Log ("Unable to instantiate prefab resource " + name);
            return;
        }
        clone.transform.parent = gameObject.transform;
        clone.transform.localPosition = Vector3.zero;
        clone.transform.localRotation = Quaternion.identity;

        if (clone.renderer != null) {
            clone.gameObject.layer = PlanetUnityOverride.puCameraLayer;
            clone.renderer.material.renderQueue = scope ().getRenderQueue () + renderQueueOffset;
        }

        foreach (Transform t in clone.transform) {
            t.gameObject.layer = PlanetUnityOverride.puCameraLayer;
            if (t.renderer != null) {
                t.renderer.material.renderQueue = scope ().getRenderQueue () + renderQueueOffset;
            }
        }
    }
Example #28
0
        internal XmlNode ReadCurrentNode(XmlDocument doc, XmlReader reader)
        {
            _doc = doc;
            _reader = reader;
            // WS are optional only for loading (see XmlDocument.PreserveWhitespace)
            _preserveWhitespace = true;
            if (doc == null)
                throw new ArgumentException(SR.Xdom_Load_NoDocument);
            if (reader == null)
                throw new ArgumentException(SR.Xdom_Load_NoReader);

            if (reader.ReadState == ReadState.Initial)
            {
                reader.Read();
            }
            if (reader.ReadState == ReadState.Interactive)
            {
                XmlNode n = LoadNode(true);

                // Move to the next node
                if (n.NodeType != XmlNodeType.Attribute)
                    reader.Read();

                return n;
            }
            return null;
        }
 private void BriefAction(XmlReader reader, ServiceAction action)
 {
     reader.Read ();
     foreach (Argument argument in action.Arguments.Values) {
         argument.Value = argument.RelatedStateVariable.DefaultValue;
     }
     while (Helper.ReadToNextElement (reader)) {
         if (!action.Arguments.ContainsKey (reader.Name)) {
             throw UpnpControlException.InvalidArgs ();
         }
         Argument argument = action.Arguments[reader.Name];
         if (argument.RelatedStateVariable.DataType.IsEnum) {
             try {
                 argument.Value = Enum.Parse (argument.RelatedStateVariable.DataType, reader.ReadString ());
             } catch {
                 throw UpnpControlException.ArgumentValueOutOfRange ();
             }
         } else {
             try {
                 argument.Value = Convert.ChangeType (reader.ReadString (), argument.RelatedStateVariable.DataType);
             } catch {
                 throw UpnpControlException.InvalidArgs ();
             }
             // TODO handle min, max, and step
         }
     }
     reader.Close ();
 }
Example #30
0
		public JsonSerializationReader (DataContractJsonSerializer serializer, XmlReader reader, Type rootType, bool verifyObjectName)
		{
			this.serializer = serializer;
			this.reader = reader;
			this.root_type = rootType;
			this.verify_object_name = verifyObjectName;
		}