/// <summary>
    /// Initializes a new instance of the <see cref="ExtendedObjectInfo"/> class.
    /// </summary>
    /// <param name="extendedTypeData">The extended type data.</param>
    /// <param name="classGroup">The class group.</param>
    internal ExtendedObjectInfo(ClassTypeInfo classTypeInfo, string classGroup)
      : base(classTypeInfo.Key, classTypeInfo.TypeName)
    {
      this.Group = classGroup;
      this.Namespace = classTypeInfo.Namespace;
      this.Modifier = (TypeModifier)Enum.Parse(typeof(TypeModifier), classTypeInfo.Modifier);
      if (classTypeInfo.BaseType != null)
      {
        this.BaseType = new ExtendedObjectInfo(classTypeInfo.BaseType, classGroup);
      }

      this.Interfaces = new List<string>();
      if (classTypeInfo.Interfaces != null && classTypeInfo.Interfaces.Count > 0)
      {
        foreach (ClassTypeInfo item in classTypeInfo.Interfaces)
        {
          this.Interfaces.Add(item.ToString());
        }
      }

      this.GenericParameters = new List<string>();
      if (classTypeInfo.GenericParameters != null && classTypeInfo.GenericParameters.Count > 0)
      {
        foreach (ClassTypeInfo item in classTypeInfo.GenericParameters)
        {
          this.GenericParameters.Add(item.ToString());
        }
      }
    }
Beispiel #2
0
    /// <summary>
    /// Adds the object.
    /// </summary>
    /// <param name="objectInfo">The object info.</param>
    public void AddObject(ClassTypeInfo objectInfo)
    {
      if (objectInfo == null)
      {
        throw new ArgumentNullException("objectInfo");
      }

      this.objectList.Add(objectInfo);
    }
Beispiel #3
0
    public void AddModelObject(ClassTypeInfo extendedTypeData, string classModelGroup)
    {
      if (extendedTypeData == null)
      {
        throw new ArgumentNullException("extendedTypeData");
      }

      ExtendedObjectInfo objectInfo = new ExtendedObjectInfo(extendedTypeData, classModelGroup);
      DiagramContext.DiagramObjects.Add(objectInfo);
    }
Beispiel #4
0
 /// <summary>
 /// Adds the model object.
 /// </summary>
 /// <param name="extendedTypeData">The extended type data.</param>
 public void AddModelObject(ClassTypeInfo extendedTypeData)
 {
   this.AddModelObject(extendedTypeData, "default");
 }
Beispiel #5
0
    /// <summary>
    /// Adds the new object.
    /// </summary>
    /// <param name="typeDeclaration">The type declaration.</param>
    /// <param name="startType">The start type.</param>
    /// <param name="includeBase">if set to <c>true</c> include base type info.</param>
    /// <returns>
    /// The base type declaration of the given type declaration; null if not within the same namespace or not found.
    /// </returns>
    internal ITypeDeclaration AddNewObject(ITypeDeclaration typeDeclaration, string startType, bool includeBase)
    {
      // Remove the current type from the additional load list.
      if (this.AdditionalLoadList.Find(typeInfo => typeInfo == typeDeclaration) != null)
      {
        this.AdditionalLoadList.Remove(typeDeclaration);
      }

      if (this.TypeDataList.Find(typeInfo => string.Compare(typeInfo.TypeName, typeDeclaration.Name, StringComparison.Ordinal) == 0) != null)
      {
        // Type already added
        Logger.Current.Info("The type has already been added to the list..." + typeDeclaration.ToString());
        return null;
      }

      ITypeDeclaration baseType = null;
      ClassTypeInfo typeData = new ClassTypeInfo
      {
        StartTypeName = startType,
        Namespace = typeDeclaration.Namespace,
        TypeName = typeDeclaration.Name,
        Modifier = ReflectorHelper.DetermineModifier(typeDeclaration)
      };

      // base type
      if (typeDeclaration.BaseType != null && string.Compare(ReflectorHelper.GetNameWithResolutionScope(typeDeclaration.BaseType), "System.Object", StringComparison.Ordinal) != 0)
      {
        baseType = typeDeclaration.BaseType.Resolve();
        ClassTypeInfo baseTypeData = new ClassTypeInfo
        {
          StartTypeName = startType,
          Namespace = baseType.Namespace,
          TypeName = baseType.Name,
          Modifier = ReflectorHelper.DetermineModifier(baseType),
        };

        if (baseType.GenericType != null)
        {
          ITypeReference genericBaseType = baseType.GenericType;
          if (baseType.GenericArguments != null)
          {
            foreach (IType item in baseType.GenericArguments)
            {
              baseTypeData.GenericParameters.Add(new ClassTypeInfo
              {
                StartTypeName = startType,
                Namespace = typeDeclaration.Namespace,
                TypeName = item.ToString(),
                Modifier = ReflectorHelper.DetermineModifier(null)
              });
            }
          }

          baseType = genericBaseType.Resolve();
        }

        typeData.BaseType = baseTypeData;
      }

      // interfaces
      foreach (ITypeReference item in typeDeclaration.Interfaces)
      {
        ITypeDeclaration interfaceDeclaration = item.Resolve();
        typeData.Interfaces.Add(new ClassTypeInfo
        {
          StartTypeName = startType,
          Namespace = interfaceDeclaration.Namespace,
          TypeName = ReflectorHelper.GetName(interfaceDeclaration),
          Modifier = ReflectorHelper.DetermineModifier(interfaceDeclaration)
        });
      }

      // generic parameters
      foreach (var item in typeDeclaration.GenericArguments)
      {
        ITypeReference reference = item as ITypeReference;
        if (reference != null)
        {
          typeData.GenericParameters.Add(new ClassTypeInfo
          {
            StartTypeName = startType,
            Namespace = reference.Namespace,
            TypeName = reference.Name,
            Modifier = ReflectorHelper.DetermineModifier(reference.Resolve())
          });
        }
        else
        {
          typeData.GenericParameters.Add(new ClassTypeInfo
          {
            StartTypeName = startType,
            Namespace = typeDeclaration.Namespace,
            TypeName = item.ToString(),
            Modifier = ReflectorHelper.DetermineModifier(null)
          });
        }
      }

      //if (Settings.ShowAssociations)
      //{
      //  // properties
      //  foreach (IPropertyDeclaration item in typeDeclaration.Properties)
      //  {
      //    ITypeReference typeReference = item.PropertyType as ITypeReference;
      //    if (typeReference != null && string.Compare(typeDeclaration.Namespace, typeReference.Namespace, StringComparison.Ordinal) == 0)
      //    {
      //      ClassTypeInfo typeInfo = new ClassTypeInfo
      //      {
      //        StartTypeName = startType,
      //        Namespace = typeReference.Namespace,
      //        TypeName = typeReference.Name,
      //        Modifier = ReflectorHelper.DetermineModifier(typeReference.Resolve())
      //      };
      //      typeData.PropertyList.Add(ReflectorHelper.GetName(item), typeInfo);

      //      // Add type to the Additional load list, if it has not been loaded already.
      //      this.AddAdditionalType(typeReference);
      //    }
      //  }
      //}

      this.TypeDataList.Add(typeData);

      if (includeBase && baseType != null && string.Compare(baseType.Namespace, typeDeclaration.Namespace, StringComparison.Ordinal) == 0)
      {
        // also parse base type...
        return baseType;
      }

      return null;
    }