private static List <DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition> GenerateManagedObjectList(IEnumerable <DynamicPropertyFilterSpecGenerator.PropertyDefinition> propertyList, string startingObjectType)
        {
            List <DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition> list = new List <DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition>();
            StringBuilder stringBuilder = new StringBuilder();

            DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition managedObjectDefinition = new DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition();
            managedObjectDefinition.ObjectType = startingObjectType;
            foreach (DynamicPropertyFilterSpecGenerator.PropertyDefinition current in propertyList)
            {
                if (current.VimType == DynamicPropertyFilterSpecGenerator.VimType.ManagedObject)
                {
                    DynamicPropertyFilterSpecGenerator.AppendPropertyPath(ref stringBuilder, current.Name);
                    managedObjectDefinition.PropertyPath = stringBuilder.ToString();
                    list.Add(managedObjectDefinition);
                    managedObjectDefinition            = new DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition();
                    managedObjectDefinition.ObjectType = current.ObjectType;
                    stringBuilder = new StringBuilder();
                }
                else
                {
                    DynamicPropertyFilterSpecGenerator.AppendPropertyPath(ref stringBuilder, current.Name);
                }
            }
            if (stringBuilder.Length != 0)
            {
                managedObjectDefinition.PropertyPath = stringBuilder.ToString();
                list.Add(managedObjectDefinition);
            }
            return(list);
        }
 private static void GeneratePropertySet(ref PropertyFilterSpec result, IEnumerable <DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition> managedObjectList)
 {
     foreach (DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition current in managedObjectList)
     {
         PropertySpec   propertySpec = null;
         PropertySpec[] propSet      = result.PropSet;
         for (int i = 0; i < propSet.Length; i++)
         {
             PropertySpec propertySpec2 = propSet[i];
             if (propertySpec2.Type == DynamicPropertyFilterSpecGenerator.FixTypeName(current.ObjectType))
             {
                 propertySpec = propertySpec2;
                 break;
             }
         }
         if (propertySpec != null)
         {
             if (propertySpec.All != true)
             {
                 if (current.PropertyPath == "*")
                 {
                     propertySpec.All     = new bool?(true);
                     propertySpec.PathSet = null;
                 }
                 else
                 {
                     List <string> list = new List <string>(propertySpec.PathSet);
                     if (!list.Contains(current.PropertyPath))
                     {
                         list.Add(current.PropertyPath);
                     }
                     propertySpec.PathSet = list.ToArray();
                 }
             }
         }
         else
         {
             propertySpec = new PropertySpec();
             List <PropertySpec> list2 = new List <PropertySpec>(result.PropSet);
             propertySpec.Type = DynamicPropertyFilterSpecGenerator.FixTypeName(current.ObjectType);
             if (current.PropertyPath == "*")
             {
                 propertySpec.All = new bool?(true);
             }
             else
             {
                 propertySpec.All     = new bool?(false);
                 propertySpec.PathSet = new string[]
                 {
                     current.PropertyPath
                 };
             }
             list2.Add(propertySpec);
             result.PropSet = list2.ToArray();
         }
     }
 }
 public void SetViewData(ObjectContent objectContent, string[] properties)
 {
     Dictionary<string, ObjectContent> objectContentList = new Dictionary<string, ObjectContent>();
     objectContentList.Add(objectContent.Obj.Value, objectContent);
     Dictionary<string, ViewBase> generatedManagedObjectList = new Dictionary<string, ViewBase>();
     PropertyFilterSpec resultPropertyFilterSpec;
     Dictionary<string, List<string>> currentAllowedPropertyPath;
     DynamicPropertyFilterSpecGenerator.Generate(objectContent.Obj, properties, out resultPropertyFilterSpec, out currentAllowedPropertyPath);
     ViewBase.SetViewData(this, (string)null, currentAllowedPropertyPath, objectContentList, generatedManagedObjectList);
 }
        private static void SetPropertyTypesAndFixCasing(DynamicPropertyFilterSpecGenerator.PropertyDefinition[] propertyPathList, string startingType)
        {
            Type type = DynamicPropertyFilterSpecGenerator.GetType(startingType);
            int  i    = 0;

            while (i < propertyPathList.Length)
            {
                DynamicPropertyFilterSpecGenerator.PropertyDefinition propertyDefinition = propertyPathList[i];
                if (propertyDefinition.Name == "*")
                {
                    break;
                }
                Dictionary <string, PropertyInfo> arg_3F_0 = ViReflectionCache.GetTypeProperties(type);
                PropertyInfo propertyInfo = null;
                arg_3F_0.TryGetValue(propertyDefinition.Name.ToLower(), out propertyInfo);
                if (propertyInfo == null)
                {
                    throw new ArgumentException(string.Format(Resources.PropertyDoesNotExist, propertyDefinition.Name));
                }
                propertyDefinition.Name = VimClient.MakeCamelCase(propertyInfo.Name);
                if (propertyInfo.PropertyType == typeof(ManagedObjectReference) || propertyInfo.PropertyType == typeof(ManagedObjectReference[]))
                {
                    type = DynamicPropertyFilterSpecGenerator.GetType(string.Format("{0}_LinkedView", type.Name));
                    ViReflectionCache.GetTypeProperties(type).TryGetValue(propertyDefinition.Name.ToLower(), out propertyInfo);
                    if (propertyDefinition.VimType != DynamicPropertyFilterSpecGenerator.VimType.ManagedObject)
                    {
                        propertyDefinition.VimType = DynamicPropertyFilterSpecGenerator.VimType.ManagedObject;
                        goto IL_169;
                    }
                    if (!DynamicPropertyFilterSpecGenerator.GetType(DynamicPropertyFilterSpecGenerator.FixTypeName(propertyInfo.PropertyType.Name)).IsAssignableFrom(DynamicPropertyFilterSpecGenerator.GetType(propertyDefinition.ObjectType)))
                    {
                        throw new ArgumentException(string.Format(Resources.WrongPropertyType, propertyDefinition.Name, propertyInfo.PropertyType.Name));
                    }
                    type = DynamicPropertyFilterSpecGenerator.GetType(propertyDefinition.ObjectType);
                }
                else
                {
                    if (propertyDefinition.VimType == DynamicPropertyFilterSpecGenerator.VimType.ManagedObject)
                    {
                        throw new ArgumentException(string.Format(Resources.SpecifiedDataObjectType, propertyDefinition.Name));
                    }
                    propertyDefinition.VimType = DynamicPropertyFilterSpecGenerator.VimType.DataObject;
                    goto IL_169;
                }
IL_18D:
                i++;
                continue;
IL_169:
                type = DynamicPropertyFilterSpecGenerator.GetType(propertyInfo.PropertyType.Name);
                propertyDefinition.ObjectType = propertyInfo.PropertyType.Name;
                goto IL_18D;
            }
        }
        private static void GenerateAllowedPropertyPath(ref Dictionary <string, List <string> > allowedPropertyPath, DynamicPropertyFilterSpecGenerator.PropertyDefinition[] userSpecifiedPropertyList, DynamicPropertyFilterSpecGenerator.PropertyDefinition[] fixedPropertyList)
        {
            string text = "";
            int    num  = userSpecifiedPropertyList.Length;

            for (int i = 0; i < userSpecifiedPropertyList.Length; i++)
            {
                DynamicPropertyFilterSpecGenerator.PropertyDefinition propertyDefinition = (userSpecifiedPropertyList[i].ObjectType != null) ? userSpecifiedPropertyList[i] : fixedPropertyList[i];
                if (propertyDefinition.ObjectType != null)
                {
                    propertyDefinition.ObjectType = DynamicPropertyFilterSpecGenerator.FixTypeName(propertyDefinition.ObjectType);
                }
                text = string.Format("{0}{1}{2}", text, (text != string.Empty) ? "." : "", propertyDefinition.Name.ToLower());
                string text2 = string.Format("{0}->", text);
                if (allowedPropertyPath.ContainsKey(text))
                {
                    if (!allowedPropertyPath[text].Contains(propertyDefinition.ObjectType))
                    {
                        allowedPropertyPath[text].Add(propertyDefinition.ObjectType);
                    }
                }
                else if (allowedPropertyPath.ContainsKey(text2))
                {
                    if (propertyDefinition.ObjectType != null && !allowedPropertyPath[text2].Contains(propertyDefinition.ObjectType))
                    {
                        allowedPropertyPath[text2].Add(propertyDefinition.ObjectType);
                    }
                    if (num == 1)
                    {
                        List <string> value = allowedPropertyPath[text2];
                        allowedPropertyPath.Remove(text2);
                        allowedPropertyPath.Add(text, value);
                    }
                }
                else
                {
                    string key = (num == 1) ? text : text2;
                    allowedPropertyPath[key] = new List <string>();
                    if (propertyDefinition.ObjectType != null)
                    {
                        allowedPropertyPath[key].Add(propertyDefinition.ObjectType);
                    }
                }
                num--;
            }
        }
        public List <ViewBase> GetViewsByMorefs(IEnumerable <ManagedObjectReference> moRefs, params string[] properties)
        {
            if (moRefs == null)
            {
                throw new ArgumentNullException("moRefs");
            }
            if (this._vimService == null)
            {
                throw new InvalidOperationException(Resources.VimWebServiceNotInitialized);
            }
            if (this._serviceContent == null)
            {
                throw new InvalidOperationException(Resources.ServiceContentNotInitialized);
            }
            Dictionary <string, PropertyFilterSpec> propertyFilterSpecList = new Dictionary <string, PropertyFilterSpec>();

            foreach (ManagedObjectReference moRef in moRefs)
            {
                if (propertyFilterSpecList.ContainsKey(moRef.Type.ToLower()))
                {
                    PropertyFilterSpec propertyFilterSpec = propertyFilterSpecList[moRef.Type.ToLower()];
                    ObjectSpec[]       array = new List <ObjectSpec>((IEnumerable <ObjectSpec>)propertyFilterSpec.ObjectSet)
                    {
                        new ObjectSpec()
                        {
                            Obj = moRef
                        }
                    }.ToArray();
                    propertyFilterSpec.ObjectSet = array;
                }
                else
                {
                    PropertyFilterSpec resultPropertyFilterSpec;
                    Dictionary <string, List <string> > currentAllowedPropertyPath;
                    DynamicPropertyFilterSpecGenerator.Generate(moRef, properties, out resultPropertyFilterSpec, out currentAllowedPropertyPath);
                    propertyFilterSpecList.Add(moRef.Type.ToLower(), resultPropertyFilterSpec);
                }
            }
            PropertyFilterSpec[] propertyFilterSpecArray = new PropertyFilterSpec[propertyFilterSpecList.Values.Count];
            propertyFilterSpecList.Values.CopyTo(propertyFilterSpecArray, 0);
            ObjectContent[] objectContent = new PropertyCollector((VimClient)this, this._serviceContent.PropertyCollector).RetrieveProperties(propertyFilterSpecArray);
            return(this.GetViewsByMorefs(moRefs, objectContent, propertyFilterSpecList));
        }
        private static SelectionSpec[] GenerateSelectionSet(IEnumerable <SelectionSpec> selectionSet, IEnumerator <DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition> moListIterator, int reverseCounter)
        {
            List <SelectionSpec> list = (selectionSet != null) ? new List <SelectionSpec>(selectionSet) : new List <SelectionSpec>();

            if (reverseCounter != 1)
            {
                moListIterator.MoveNext();
                TraversalSpec traversalSpec = null;
                using (List <SelectionSpec> .Enumerator enumerator = list.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        TraversalSpec traversalSpec2 = (TraversalSpec)enumerator.Current;
                        if (moListIterator.Current.ObjectType == traversalSpec2.Type && moListIterator.Current.PropertyPath == traversalSpec2.Path)
                        {
                            traversalSpec = traversalSpec2;
                            break;
                        }
                    }
                }
                if (traversalSpec != null)
                {
                    traversalSpec.SelectSet = DynamicPropertyFilterSpecGenerator.GenerateSelectionSet(traversalSpec.SelectSet, moListIterator, --reverseCounter);
                }
                else
                {
                    traversalSpec           = new TraversalSpec();
                    traversalSpec.Type      = DynamicPropertyFilterSpecGenerator.FixTypeName(moListIterator.Current.ObjectType);
                    traversalSpec.Path      = moListIterator.Current.PropertyPath;
                    traversalSpec.Skip      = new bool?(false);
                    traversalSpec.SelectSet = DynamicPropertyFilterSpecGenerator.GenerateSelectionSet(null, moListIterator, --reverseCounter);
                    list.Add(traversalSpec);
                }
                return(list.ToArray());
            }
            if (list.Count != 0)
            {
                return(list.ToArray());
            }
            return(null);
        }
 public void UpdateViewData(params string[] properties)
 {
     PropertyCollector propertyCollector = new PropertyCollector(this._client, this._client.ServiceContent.PropertyCollector);
     PropertyFilterSpec resultPropertyFilterSpec;
     Dictionary<string, List<string>> currentAllowedPropertyPath;
     DynamicPropertyFilterSpecGenerator.Generate(this.MoRef, VimClient.MakePropertiesCamelCase(properties), out resultPropertyFilterSpec, out currentAllowedPropertyPath);
     PropertyFilterSpec[] specSet = new PropertyFilterSpec[1]
     {
 resultPropertyFilterSpec
     };
     ObjectContent[] objectContentArray = propertyCollector.RetrieveProperties(specSet);
     Dictionary<string, ObjectContent> objectContentList = new Dictionary<string, ObjectContent>();
     foreach (ObjectContent objectContent in objectContentArray)
         objectContentList.Add(objectContent.Obj.Value, objectContent);
     Dictionary<string, ViewBase> generatedManagedObjectList = new Dictionary<string, ViewBase>();
     if (properties != null)
     {
         List<string> stringList = new List<string>((IEnumerable<string>)properties);
     }
     ViewBase.SetViewData(this, (string)null, currentAllowedPropertyPath, objectContentList, generatedManagedObjectList);
 }
        internal static void Generate(ManagedObjectReference startingObject, string[] propertyPathList, out PropertyFilterSpec resultPropertyFilterSpec, out Dictionary <string, List <string> > currentAllowedPropertyPath)
        {
            resultPropertyFilterSpec = new PropertyFilterSpec();
            ObjectSpec objectSpec = new ObjectSpec();

            resultPropertyFilterSpec.ObjectSet = new ObjectSpec[]
            {
                objectSpec
            };
            objectSpec.Obj                   = startingObject;
            objectSpec.SelectSet             = new SelectionSpec[0];
            resultPropertyFilterSpec.PropSet = new PropertySpec[0];
            currentAllowedPropertyPath       = null;
            if (propertyPathList == null)
            {
                PropertySpec propertySpec = new PropertySpec();
                propertySpec.Type = startingObject.Type;
                propertySpec.All  = new bool?(true);
                resultPropertyFilterSpec.PropSet = new PropertySpec[]
                {
                    propertySpec
                };
                return;
            }
            currentAllowedPropertyPath = new Dictionary <string, List <string> >();
            for (int i = 0; i < propertyPathList.Length; i++)
            {
                DynamicPropertyFilterSpecGenerator.PropertyDefinition[]      array = DynamicPropertyFilterSpecGenerator.ParsePropertyPath(propertyPathList[i]);
                List <DynamicPropertyFilterSpecGenerator.PropertyDefinition> list  = new List <DynamicPropertyFilterSpecGenerator.PropertyDefinition>(array);
                DynamicPropertyFilterSpecGenerator.SetPropertyTypesAndFixCasing(array, startingObject.Type);
                DynamicPropertyFilterSpecGenerator.GenerateAllowedPropertyPath(ref currentAllowedPropertyPath, list.ToArray(), array);
                List <DynamicPropertyFilterSpecGenerator.ManagedObjectDefinition> list2 = DynamicPropertyFilterSpecGenerator.GenerateManagedObjectList(array, startingObject.Type);
                DynamicPropertyFilterSpecGenerator.GeneratePropertySet(ref resultPropertyFilterSpec, list2);
                resultPropertyFilterSpec.ObjectSet[0].SelectSet = DynamicPropertyFilterSpecGenerator.GenerateSelectionSet(resultPropertyFilterSpec.ObjectSet[0].SelectSet, list2.GetEnumerator(), list2.Count);
            }
        }
 private static Type GetType(string typeName)
 {
     return(ViReflectionCache.GetTypeByRemoteTypeAndName(typeof(ManagedObjectReference), DynamicPropertyFilterSpecGenerator.FixTypeName(typeName)));
 }