public TypeMap CreateTypeMap(Type sourceType, Type destinationType, ProfileMap options, MemberList memberList)
        {
            var sourceTypeInfo = options.CreateTypeDetails(sourceType);
            var destTypeInfo = options.CreateTypeDetails(destinationType);

            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList, options);

            foreach (var destProperty in destTypeInfo.PublicWriteAccessors)
            {
                var resolvers = new LinkedList<MemberInfo>();

                if (MapDestinationPropertyToSource(options, sourceTypeInfo, destProperty.DeclaringType, destProperty.GetMemberType(), destProperty.Name, resolvers))
                {
                    typeMap.AddPropertyMap(destProperty, resolvers);
                }
            }
            if (!destinationType.IsAbstract() && destinationType.IsClass())
            {
                foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length))
                {
                    if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
                    {
                        break;
                    }
                }
            }
            return typeMap;
        }

 void SymbolTableUpdateEventHandler(Compilation updatedSymbolTable, UpdateSpecification updateSpecification, MemberList changedMembers){
   lock(this){
     Thread savedCurrentThread = this.currentThread;
     if (Thread.CurrentThread == this.currentThread) Console.WriteLine("Update event called on same thread as the one causing the update");
     if (!Thread.CurrentThread.IsThreadPoolThread) Console.WriteLine("Updated event called from a non thread pool thread");
     if (!Thread.CurrentThread.IsBackground) Console.WriteLine("Updated event called from a non background thread");
     this.currentThread = Thread.CurrentThread;
     if (updatedSymbolTable == null){Console.WriteLine("SymbolTable update with null value for updatedSymbolTable"); return;}
     if (updatedSymbolTable.TargetModule == null){Console.WriteLine("SymbolTable update with null value for updatedSymbolTable.TargetModule"); return;}
     Console.WriteLine("Received update event on symbol table: {0}", ((Compilation)updateSpecification.Original).TargetModule.Name);
     for (int i = 0, n = changedMembers == null ? 0 : changedMembers.Count; i < n; i++){
       Member mem = changedMembers[i];
       if (mem == null)
         Console.WriteLine("changedMembers[{0}] == null", i);
       else
         Console.WriteLine("changedMembers[{0}].FullName == {1}", i, mem.FullName);
     }
     for (int i = 0, n = this.compilations.Count; i < n; i++){
       Compilation compilation = this.compilations[i];
       if (compilation == null || compilation == updateSpecification.Original) continue;
       for (int j = 0, m = compilation.ReferencedCompilations == null ? 0 : compilation.ReferencedCompilations.Count; j < m; j++){
         Compilation rComp = compilation.ReferencedCompilations[j];
         if (rComp != updateSpecification.Original) continue;
         Compilation upd = this.compiler.UpdateSymbolTable(compilation, (Compilation)updateSpecification.Original, updatedSymbolTable, changedMembers, this.errors);
         if (upd == null){
           Console.WriteLine("Referenced compilation {0} was not updated", j);
         }else
           this.CheckUpdatedCompilation(compilation, upd);
       }
     }
     this.currentThread = savedCurrentThread;
   }
 }

 public TypeMap(TypeInfo sourceType, TypeInfo destinationType, MemberList memberList)
 {
     _sourceType = sourceType;
     _destinationType = destinationType;
     Profile = ConfigurationStore.DefaultProfileName;
     ConfiguredMemberList = memberList;
 }

        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IProfileConfiguration options, MemberList memberList)
        {
            var sourceTypeInfo = GetTypeInfo(sourceType, options);
            var destTypeInfo = GetTypeInfo(destinationType, options);

            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList, options.ProfileName);

            foreach (var destProperty in destTypeInfo.PublicWriteAccessors)
            {
                var resolvers = new LinkedList<IValueResolver>();

                if (MapDestinationPropertyToSource(options, sourceTypeInfo, destProperty.GetMemberType(), destProperty.Name, resolvers))
                {
                    var destPropertyAccessor = destProperty.ToMemberAccessor();

                    typeMap.AddPropertyMap(destPropertyAccessor, resolvers);
                }
            }
            if (!destinationType.IsAbstract() && destinationType.IsClass())
            {
                foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length))
                {
                    if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
                    {
                        break;
                    }
                }
            }
            return typeMap;
        }

        //internal static ICollection<IChildMemberConfiguration> sourceToDestinationMemberMappers = new Collection<IChildMemberConfiguration>
        //{
        //    // Need to do it fixie way for prefix and postfix to work together + not specify match explicitly
        //    // Have 3 properties for Members, Methods, And External Methods
        //    // Parent goes to all
        //    new MemberConfiguration().AddMember<NameSplitMember>().AddName<PrePostfixName>(_ => _.AddStrings(p => p.Prefixes, "Get")).SetMemberInfo<AllMemberInfo>(),
        //    //new CustomizedSourceToDestinationMemberMapper().MemberNameMatch().ExtensionNameMatch().ExtensionPrefix("Get").MethodPrefix("Get").MethodNameMatch(),
        //};
        //internal static readonly ICollection<IChildMemberConfiguration> def = sourceToDestinationMemberMappers.ToList();
        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IProfileConfiguration options,
            MemberList memberList)
        {
            var sourceTypeInfo = GetTypeInfo(sourceType, options);
            var destTypeInfo = GetTypeInfo(destinationType, options);

            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList);

            foreach (var destProperty in destTypeInfo.PublicWriteAccessors)
            {
                var members = new LinkedList<MemberInfo>();

                if (MapDestinationPropertyToSource(options, sourceTypeInfo, destProperty.GetType(), destProperty.Name,
                    members))
                {
                    var resolvers = members.Select(mi => ReflectionHelper.ToMemberGetter(mi));
                    var destPropertyAccessor = ReflectionHelper.ToMemberAccessor(destProperty);

                    typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>());
                }
            }
            if (!TypeExtensions.IsAbstract(destinationType) && TypeExtensions.IsClass(destinationType))
            {
                foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length))
                {
                    if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
                    {
                        break;
                    }
                }
            }
            return typeMap;
        }

        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options,
            MemberList memberList)
        {
            var sourceTypeInfo = GetTypeInfo(sourceType, options);
            var destTypeInfo = GetTypeInfo(destinationType, options.ShouldMapProperty, options.ShouldMapField, new MethodInfo[0]);

            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList);

            foreach (var destProperty in destTypeInfo.PublicWriteAccessors)
            {
                var members = new LinkedList<MemberInfo>();

                if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
                {
                    var resolvers = members.Select(mi => mi.ToMemberGetter());
                    var destPropertyAccessor = destProperty.ToMemberAccessor();

                    typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>());
                }
            }
            if (!destinationType.IsAbstract() && destinationType.IsClass())
            {
                foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length))
                {
                    if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
                    {
                        break;
                    }
                }
            }
            return typeMap;
        }

        public override MemberList Process(WebClient client)
        {
            MemberList ml = new MemberList();

            String content = client.DownloadString(GetUrl());

            MatchCollection mc = Regex.Matches(content, "<option value=\"(\\d+)\">(.+?)</option>");
            foreach (Match m in mc)
            {
                String id = m.Groups[1].Value;
                String name = m.Groups[2].Value;

                if (id != "0")
                {
                    CategoryTop c = new CategoryTop();
                    c.Name = name;
                    c.Id = id;

                    Children.Add(c);
                    ml.Add(c);
                }
            }

            Unprocessed = false;
            return ml;
        }

 public void showChildWindow(AdminService.MemberList info)
 {
     UserID = info.UserID;
     org = info;
     memList = ModelCopy.CopyValueForModel<MemberList>(info);
     base.Show();
 }

 public TypeMap(TypeDetails sourceType, TypeDetails destinationType, MemberList memberList, ProfileMap profile)
 {
     SourceTypeDetails = sourceType;
     DestinationTypeDetails = destinationType;
     Types = new TypePair(sourceType.Type, destinationType.Type);
     Profile = profile;
     ConfiguredMemberList = memberList;
 }

 public TypeMap(TypeDetails sourceType, TypeDetails destinationType, MemberList memberList)
 {
     _sourceType = sourceType;
     _destinationType = destinationType;
     Types = new TypePair(sourceType.Type, destinationType.Type);
     Profile = ConfigurationStore.DefaultProfileName;
     ConfiguredMemberList = memberList;
 }

 public Facede(Bll.Facede Application)
 {
     column = new Column(Application);
     corporationList = new CorporationList(Application);
     list = new List(Application);
     listColumn = new ListColumn(Application);
     listItem = new ListItem(Application);
     memberList = new MemberList(Application);
 }

 public MemberList GetUnprocessedChildren()
 {
     MemberList ml = new MemberList();
     Children.ForEach(delegate(AbstractMember m)
     {
         ml.AddRange(m.GetUnprocessedChildren());
     });
     return ml;
 }

 public TypeMap(TypeDetails sourceType, TypeDetails destinationType, MemberList memberList, IProfileConfiguration profile)
 {
     SourceTypeDetails = sourceType;
     DestinationTypeDetails = destinationType;
     Types = new TypePair(sourceType.Type, destinationType.Type);
     Profile = profile;
     ConfiguredMemberList = memberList;
     IgnorePropertiesStartingWith = profile.GlobalIgnores;
 }

        public override MemberList Process(WebClient client)
        {
            MemberList ml = new MemberList();
            String content = client.DownloadString(GetUrl());

            MatchCollection mc = Regex.Matches(content,
                "<a href=\"http://baki\\.info/subcat/(\\d+)\" class=\"sc_listone\">.*?<span class=\"csc_sub_name\"><div class=\"title_inner\">(.+?)</div>", RegexOptions.Singleline);
            if (mc.Count > 0)
            {
                // process sub categories
                foreach (Match m in mc)
                {
                    CategorySub c = new CategorySub();
                    c.Id = m.Groups[1].Value;
                    c.Name = m.Groups[2].Value.Replace("&nbsp;", " ").Replace("&amp;", "&").Trim();

                    Children.Add(c);
                    ml.Add(c);
                }

                Unprocessed = false;
            }
            else
            {
                // process products
                content = client.DownloadString(ProductsUrl(page));

                MatchCollection mc1 = Regex.Matches(content, "<div class=\"cop_title\"><h3><a href=\"(.+?)\">(.+?)</a></h3></div>");

                foreach (Match m in mc1)
                {
                    Product p = new Product();
                    p.Name = m.Groups[2].Value.Replace("&nbsp;", " ").Replace("&amp;", "&").Trim();
                    p.Url = m.Groups[1].Value;

                    Children.Add(p);
                    ml.Add(p);
                }

                MatchCollection mc2 = Regex.Matches(content, "new Paginator\\('paginator1', (\\d+?), \\d+, (\\d+?), \"#\"\\);");
                String total = mc2[0].Groups[1].Value;
                String current = mc2[0].Groups[2].Value;

                if (page < Int16.Parse(total))
                {
                    Page++;
                    ml.Add(this);
                }
                else
                {
                    Unprocessed = false;
                }

            }

            return ml;
        }

 public virtual MemberList GetNestedNamespaces(Identifier name, Scope scope) {
   MemberList fullList = this.GetNestedNamespacesAndTypes(name, scope);
   MemberList result = new MemberList();
   for (int i = 0, n = fullList == null ? 0 : fullList.Count; i < n; i++){
     Namespace ns = fullList[i] as Namespace;
     if (ns == null) continue;
     result.Add(ns);
   }
   return result;
 }

 public override MemberList VisitMemberList(MemberList members){
   if (members == null) return null;
   for (int i = 0, n = members.Count; i < n; i++){
     Member mem = members[i]; if (mem == null) continue;
     if (this.Line != int.MinValue){
       if (!mem.SourceContext.Encloses(this.Line, this.Column)) continue;
     }else{
       if (!mem.SourceContext.Encloses(this.SourceContext)) continue;
     }
     this.Visit(mem);
     break;
   }
   return members;
 }

 public override MemberList GetTypesNamespacesAndPrefixes(Scope scope, bool constructorMustBeVisible, bool listAllUnderRootNamespace) {
   MemberList result = new MemberList();
   while (scope != null && !(scope is TypeScope || scope is NamespaceScope)) scope = scope.OuterScope;
   if (scope == null) return result;
   TypeNode currentType = scope is TypeScope ? ((TypeScope)scope).Type : null;
   if (!(scope is NamespaceScope) && (currentType == null || currentType.DeclaringModule == null)) return result;
   ErrorHandler errorHandler = new ErrorHandler(new ErrorNodeList(0));
   TrivialHashtable ambiguousTypes = new TrivialHashtable();
   TrivialHashtable referencedLabels = new TrivialHashtable();
   Looker looker = new Looker(null, errorHandler, null, ambiguousTypes, referencedLabels);
   looker.currentType = currentType;
   looker.currentModule = this.currentSymbolTable;
   looker.currentAssembly = looker.currentModule as AssemblyNode;
   result = looker.GetVisibleTypesNamespacesAndPrefixes(scope, constructorMustBeVisible, listAllUnderRootNamespace);
   return result;
 }

        public override MemberList Process(WebClient client)
        {
            MemberList ml = new MemberList();
            String content = client.DownloadString(GetUrl());

            MatchCollection mc = Regex.Matches(content,
                "<a href=\"http://baki\\.info/subcat/(\\d+)\" class=\"sc_listone\">.*?<span class=\"csc_sub_name\"><div class=\"title_inner\">(.+?)</div>", RegexOptions.Singleline);
            foreach (Match m in mc)
            {
                CategorySub c = new CategorySub();
                c.Id = m.Groups[1].Value;
                c.Name = m.Groups[2].Value;

                Children.Add(c);
                ml.Add(c);

            }

            Unprocessed = false;
            return ml;
        }

        public override void VisitMemberList(MemberList members)
        {
            if (members == null) return;

            for (int i = 0, n = members.Count; i < n; i++)
            {
                var type = members[i] as TypeNode;

                if (type == null) continue;

                Class c = type as Class;
                if (c != null && HelperMethods.IsContractTypeForSomeOtherType(c))
                {
                    members[i] = null;
                }
                else
                {
                    // for nested types
                    this.VisitTypeNode(type);
                }
            }
        }

    public void OnEventHandling(int node, NetEventState state)
    {
        string str = "Node:" + node + " type:" + state.type.ToString() + " State:" + state.type + "[" + state.result + "]";
        Debug.Log("OnEventHandling called");
        Debug.Log(str);

        switch (state.type) {
        case NetEventType.Connect: {
            MemberList member = new MemberList();

            member.node = node;
            member.endPoint = network_.GetEndPoint(node);

            m_members.Add(node, member);
        } 	break;

        case NetEventType.Disconnect: {

            if (m_members.ContainsKey(node)) {

                int roomId = m_members[node].roomId;
                if (rooms_.ContainsKey(roomId)) {
                    for (int i = 0; i < rooms_[roomId].members.Length; ++i) {
                        if (rooms_[roomId].members[i] == node) {
                            rooms_[roomId].members[i] = -1;
                            break;
                        }
                    }
                }

                m_members.Remove(node);
            }
        }	break;

        }
    }