public Type LoadTypeFromDescriptor(TypeDescriptor typeDescriptor)
 {
     if (typeDescriptor.TypeDescriptors.Count == 0)
         return LoadTypeFromName(typeDescriptor.Name);
     var typeParams = typeDescriptor
         .TypeDescriptors
         .Select(LoadTypeFromDescriptor)
         .ToArray();
     return LoadTypeFromName(typeDescriptor.Name, typeParams);
 }

 public MethodDescriptor FindMethodImplementation(MethodDescriptor methodDescriptor, TypeDescriptor typeDescriptor)
 {
     var roslynMethod = FindMethod(methodDescriptor);
     if (roslynMethod != null)
     {
         var roslynType = RoslynSymbolFactory.GetTypeByName(typeDescriptor.TypeName, this.Compilation);
         var implementedMethod = Utils.FindMethodImplementation(roslynMethod, roslynType);
         return new MethodDescriptor(implementedMethod);
     }
     // If we cannot resolve the method, we return the same method.
     return methodDescriptor;
 }

 public IXILMapping TryAllocate(Component host, XILInstr instr, TypeDescriptor[] operandTypes, TypeDescriptor[] resultTypes, IProject proj)
 {
     List<IXILMapper> mappers = _mlookup.Get(instr.Name);
     foreach (IXILMapper mapper in mappers)
     {
         IXILMapping mapping = mapper.TryAllocate(host, instr, operandTypes, resultTypes, proj);
         if (mapping != null)
         {
             return mapping;
         }
     }
     return null;
 }

        internal static string GetName(this MemberInfo @this, Assembly containingAssembly, 
			bool isDeclaration)
        {
            var methodName = string.Empty;

            if(!isDeclaration)
            {
                methodName += new TypeDescriptor(
                    @this.DeclaringType, containingAssembly,
                    @this.DeclaringType.IsGenericType).Value + "::";
            }

            return methodName + @this.Name;
        }

        /// <summary>
        /// Initialize a new instance of <see cref="PropertyDescriptor"/>.
        /// </summary>
        /// <param name="propertyInfo">The <see cref="PropertyInfo"/> to wrap.</param>
        /// <param name="typeDescriptor">The <see cref="Reflection.TypeDescriptor"/> this <see cref="PropertyDescriptor"/> belongs to.</param>
        /// <param name="getMethodInfo">The get <see cref="MethodInfo"/> for the <see cref="PropertyInfo"/> being wrapped.</param>
        /// <exception cref="NullReferenceException"><paramref name="propertyInfo"/> is null.</exception>
        internal PropertyDescriptor(TypeDescriptor typeDescriptor, PropertyInfo propertyInfo, MethodInfo getMethodInfo)
            : base(getMethodInfo.ReturnType, propertyInfo.Name)
        {
            if (propertyInfo.PropertyType.IsGenericParameter)
            {
                throw new ArgumentException("propertyInfo cannot be a genetic type.", "propertyInfo");
            }
            TypeDescriptor = typeDescriptor;
            IsStatic = getMethodInfo.IsStatic;
            IsVirtual = getMethodInfo.IsVirtual;
#if(WindowsCE || SILVERLIGHT)
            this.getMethodInfo = getMethodInfo;
#else
            invoker = MethodInvokerCreator.GetMethodInvoker(getMethodInfo);
#endif
			AddRulesForPropertyInfo(propertyInfo);
        }

        public StandartTypeManager()
        {
            foreach (var item in Enum.GetValues(typeof(DataType)))
            {
                DataType typeEnum = (DataType)item;
                string alias;
                switch (typeEnum)
                {
                    case DataType.Undefined:
                        alias = "Неопределено";
                        break;
                    case DataType.Boolean:
                        alias = "Булево";
                        break;
                    case DataType.String:
                        alias = "Строка";
                        break;
                    case DataType.Date:
                        alias = "Дата";
                        break;
                    case DataType.Number:
                        alias = "Число";
                        break;
                    case DataType.Type:
                        alias = "Тип";
                        break;
                    case DataType.Object:
                        alias = "Object";
                        break;
                    default:
                        continue;
                }

                var td = new TypeDescriptor()
                {
                    Name = alias,
                    ID = (int)typeEnum
                };

                RegisterType(td, typeof(DataType));

            }

            RegisterType("Null", typeof(NullValueImpl));
        }

        public void ToTypedKeyValue_WhenJsonWithDataTypes_DictionaryGetsTypedValues()
        {
            const string json = "{\"Name\":\"Daniel\",\"Age\":31,\"Item\":{\"Int1\":42,\"DateTime1\":\"\\/Date(-3600000+0000)\\/\"}}";
            var typeDescriptor = new TypeDescriptor
                                 {
                                     {"Name", typeof (string)},
                                     {"Age", typeof (int)},
                                     {"Item", typeof (Item)},
                                 };

            var kv = _jsonSerializer.ToTypedKeyValueOrNull(typeDescriptor, json);

            var expectedKv = new Dictionary<string, object>
                             {
                                 {"Name", "Daniel"},{"Age", 31}, {"Item", new Item{Int1 = 42, DateTime1 = new DateTime(1970,01,01)}}
                             };
            CustomAssert.KeyValueEquality(expectedKv, kv);
        }

        public bool SentAll(IEnumerable<IDistributedEventAggregator> eventAggregators, byte[] messageContent,
            TypeDescriptor descriptor)
        {
            Logger = LogManager.GetLogger(NomadConstants.NOMAD_LOGGER_REPOSITORY, typeof (BasicTopicDeliverySubsystem));

            foreach (IDistributedEventAggregator dea in eventAggregators)
            {
                try
                {
                    dea.OnPublish(messageContent, descriptor);
                }
                catch (Exception e)
                {
                    Logger.Warn(string.Format("Could not sent message '{0}' to DEA: {1}", descriptor, dea), e);
                }
            }

            // using the reliable mechanisms of WCF devlivery is always succesfull to all proper processes
            return true;
        }

 /// <summary>
 /// Internalizes a type descriptor.
 /// </summary>
 /// <param name="td">a type descriptor</param>
 /// <returns>equivalent type descriptor which is contained inside the library</returns>
 public TypeDescriptor Canonicalize(TypeDescriptor td)
 {
     TypeDescriptor tdOut;
     if (_types.TryGetValue(td, out tdOut))
     {
         return tdOut;
     }
     else
     {
         td = td.Clone();
         _types[td] = td;
         if (!td.HasIntrinsicTypeOverride)
         {
             PackageDescriptor pd = GetPackage(td.CILType);
             td.Package = pd;
             pd.AddChild(td, td.Name);
         }
         return td;
     }
 }

        /// <summary>
        /// Initialize a new instance of <see cref="FieldDescriptor"/>.
        /// </summary>
        /// <param name="fieldInfo">The <see cref="FieldInfo"/> to wrap.</param>
        /// <param name="typeDescriptor">The <see cref="Reflection.TypeDescriptor"/> this <see cref="FieldDescriptor"/> belongs to.</param>
        /// <exception cref="NullReferenceException"><paramref name="fieldInfo"/> is null.</exception>
        internal FieldDescriptor(TypeDescriptor typeDescriptor, FieldInfo fieldInfo)
            : base(fieldInfo.FieldType, fieldInfo.Name)
        {
            if (fieldInfo.FieldType.IsGenericParameter)
            {
                throw new ArgumentException("fieldInfo cannot be a genetic type.", "fieldInfo");
            }
            //TODO: Use Dynamic method instead
            this.fieldInfo = fieldInfo;
            TypeDescriptor = typeDescriptor;
            IsStatic = fieldInfo.IsStatic;
//            invoker = MethodInvokerCreator.GetFieldGetInvoker(Type.GetTypeFromHandle(typeDescriptor.RuntimeTypeHandle), fieldInfo);
			var attributes = (IRuleAttribute[])fieldInfo.GetCustomAttributes(RuleAttributeType, true);
            for (var index = 0; index < attributes.Length; index++)
            {
				var fieldRuleAttribute = attributes[index];
                //Make sure each attribute is "aware" of the fieldInfo it's validating
                var rule = fieldRuleAttribute.CreateRule(this);
                Rules.Add(rule);
            }
        }

        internal static void UnPackData(TypeDescriptor typeDescriptor, byte[] byteStream, out object sendObject, out Type type)
        {
            type = Type.GetType(typeDescriptor.QualifiedName);
            if (type != null)
            {
                var nomadVersion = new Version(type.Assembly.GetName().Version);

                if (!nomadVersion.Equals(typeDescriptor.Version))
                {
                    throw new InvalidCastException("The version of the assembly does not match");
                }
            }

            // try deserializing object
            sendObject = Deserialize(byteStream);

            // check if o is assignable
            if (type != null && !type.IsInstanceOfType(sendObject))
            {
                throw new InvalidCastException("The sent object cannot be casted to sent type");
            }
        }

        public IDictionary<string, object> ToTypedKeyValueOrNull(TypeDescriptor typeDescriptor, string json)
        {
            if (string.IsNullOrWhiteSpace(json))
                return null;

            var kvRepresentation = Serializer.Deserialize<IDictionary<string, dynamic>>(json);
            if (kvRepresentation == null || kvRepresentation.Count < 1)
                return null;

            foreach (var key in kvRepresentation.Keys.ToArray())
            {
                var membername = key;
                var member = typeDescriptor.Get(membername);

                if (member == null)
                    continue;

                kvRepresentation[membername] = JsonSerializer.DeserializeFromString(kvRepresentation[membername], member.Type);
            }

            return kvRepresentation;
        }

 private string GetTypeString(TypeDescriptor td)
 {
     if (td.CILType.Equals(typeof(StdLogic)))
         return "std_logic";
     else if (td.CILType.Equals(typeof(StdLogicVector)))
         return "std_logic_vector(" + td.Constraints[0].FirstBound + " downto " + td.Constraints[0].SecondBound + ")";
     else
         throw new NotSupportedException("Only StdLogic/StdLogicVector supported for user ports");
 }

 public virtual bool Enter(TypeDescriptor node)
 {
     return true;
 }

        public TypeDescriptor RegisterType(string name, Type implementingClass)
        {
            if (_knownTypesIndexes.ContainsKey(name))
            {
                var td = GetTypeByName(name);
                if (GetImplementingClass(td.ID) != implementingClass)
                    throw new InvalidOperationException("Name already registered");

                return td;
            }
            else
            {
                var nextId = _knownTypes.Count;
                var typeDesc = new TypeDescriptor()
                {
                    ID = nextId,
                    Name = name
                };

                RegisterType(typeDesc, implementingClass);
                return typeDesc;
            }
        }

 public static void RegisterAliasFor(TypeDescriptor td, string alias)
 {
     _instance.RegisterAliasFor(td, alias);
 }

 public SortDirectionEnum(TypeDescriptor typeRepresentation, TypeDescriptor valuesType)
     : base(typeRepresentation, valuesType)
 {
 }

        private static void WriteReport(Histogram[] histogram, string[] timeMarker)
        {
            TypeDescriptor[] typeIndexToTypeDescriptor = new TypeDescriptor[histogram[0].readNewLog.typeName.Length];

            int[] totalSize = new int[histogram.Length];
            int[] totalCount = new int[histogram.Length];
            for (int h = 0; h < histogram.Length; h++)
            {
                int[] typeSizeStacktraceToCount = histogram[h].typeSizeStacktraceToCount;

                for (int i = 0; i < typeSizeStacktraceToCount.Length; i++)
                {
                    int count = typeSizeStacktraceToCount[i];
                    if (count == 0)
                        continue;

                    int[] stacktrace = histogram[h].readNewLog.stacktraceTable.IndexToStacktrace(i);
                    int typeIndex = stacktrace[0];
                    int size = stacktrace[1];

                    if (typeIndexToTypeDescriptor[typeIndex] == null)
                        typeIndexToTypeDescriptor[typeIndex] = new TypeDescriptor(typeIndex, histogram.Length);
                    typeIndexToTypeDescriptor[typeIndex].size[h] += size*count;
                    typeIndexToTypeDescriptor[typeIndex].count[h] += count;

                    totalSize[h] += size*count;
                    totalCount[h] += count;
                }
            }

            ArrayList al = new ArrayList();
            for (int i = 0; i < typeIndexToTypeDescriptor.Length; i++)
            {
                if (typeIndexToTypeDescriptor[i] == null)
                    continue;
                al.Add(typeIndexToTypeDescriptor[i]);
            }
            al.Sort();

            Console.Write("Typename");
            for (int h = 0; h < histogram.Length; h++)
                Console.Write(",Size({0}),#Instances({1})", timeMarker[h], timeMarker[h]);
            Console.WriteLine();
            
            Console.Write("Grand total");
            for (int h = 0; h < histogram.Length; h++)
                Console.Write(",{0},{1}", totalSize[h], totalCount[h]);
            Console.WriteLine();

            foreach (TypeDescriptor td in al)
            {
                Console.Write("{0}", histogram[0].readNewLog.typeName[td.typeIndex]);
                for (int h = 0; h < histogram.Length; h++)
                    Console.Write(",{0},{1}", td.size[h], td.count[h]);
                Console.WriteLine();
            }
        }

 public virtual void Exit(TypeDescriptor node)
 {
 }

        public IEnumerable<IXILMapping> TryMap(ITransactionSite taSite, XILInstr instr, TypeDescriptor[] operandTypes, TypeDescriptor[] resultTypes)
        {
            IFixedAbsTransactionSite fats = taSite as IFixedAbsTransactionSite;
            if (fats == null)
                yield break;

            if (instr.Name != InstructionCodes.Abs)
                yield break;

            var operandFormat = operandTypes[0].GetFixFormat();
            if (operandFormat == null)
                yield break;

            var resultFormat = resultTypes[0].GetFixFormat();
            if (resultFormat == null)
                yield break;

            if (operandFormat.FracWidth != resultFormat.FracWidth)
                yield break;

            if (operandFormat.TotalWidth != fats.Host.InputWidth)
                yield break;

            if (resultFormat.TotalWidth != fats.Host.OutputWidth)
                yield break;

            yield return new AbsMapping(fats.Host);
        }