ToArray() private method

private ToArray ( Type type ) : Array
type Type
return Array
		/// <summary>
		/// Creates a NDataReader from a <see cref="IDataReader" />
		/// </summary>
		/// <param name="reader">The <see cref="IDataReader" /> to get the records from the Database.</param>
		/// <param name="isMidstream"><see langword="true" /> if we are loading the <see cref="IDataReader" /> in the middle of reading it.</param>
		/// <remarks>
		/// NHibernate attempts to not have to read the contents of an <see cref="IDataReader"/> into memory until it absolutely
		/// has to.  What that means is that it might have processed some records from the <see cref="IDataReader"/> and will
		/// pick up the <see cref="IDataReader"/> midstream so that the underlying <see cref="IDataReader"/> can be closed 
		/// so a new one can be opened.
		/// </remarks>
		public NDataReader(IDataReader reader, bool isMidstream)
		{
			ArrayList resultList = new ArrayList(2);

			try
			{
				// if we are in midstream of processing a DataReader then we are already
				// positioned on the first row (index=0)
				if (isMidstream)
				{
					currentRowIndex = 0;
				}

				// there will be atleast one result 
				resultList.Add(new NResult(reader, isMidstream));

				while (reader.NextResult())
				{
					// the second, third, nth result is not processed midstream
					resultList.Add(new NResult(reader, false));
				}

				results = (NResult[]) resultList.ToArray(typeof(NResult));
			}
			catch (Exception e)
			{
				throw new ADOException("There was a problem converting an IDataReader to NDataReader", e);
			}
			finally
			{
				reader.Close();
			}
		}
        public override ClassDefinition GetClassDefinition(object instance)
        {
            Type type = instance.GetType();
            BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Instance;
            PropertyInfo[] propertyInfos = type.GetProperties(bindingAttr);
#if !(NET_1_1)
            List<ClassMember> classMemberList = new List<ClassMember>();
#else
            ArrayList classMemberList = new ArrayList();
#endif
            for (int i = 0; i < propertyInfos.Length; i++)
            {
                PropertyInfo propertyInfo = propertyInfos[i];
                if (propertyInfo.Name != "HelpLink" && propertyInfo.Name != "TargetSite")
                {
                    ClassMember classMember = new ClassMember(propertyInfo.Name, bindingAttr, propertyInfo.MemberType, null);
                    classMemberList.Add(classMember);
                }
            }
            string customClassName = type.FullName;
            customClassName = FluorineConfiguration.Instance.GetCustomClass(customClassName);
#if !(NET_1_1)
            ClassMember[] classMembers = classMemberList.ToArray();
#else
			ClassMember[] classMembers = classMemberList.ToArray(typeof(ClassMember)) as ClassMember[];
#endif
			ClassDefinition classDefinition = new ClassDefinition(customClassName, classMembers, GetIsExternalizable(instance), GetIsDynamic(instance));
            return classDefinition;
        }
Example #3
0
	public Item[] ListChildrenOf(string url)
	{
		Logger.LogMethod();
		try
		{
			using (new UserImpersonator())
			{
				ArrayList list = new ArrayList();
				object o = SharePointHelper.GetSharePointObject(url);
				if (o is SPWeb)
				{
					using (SPWeb web = o as SPWeb)
					{
						PopulateListOfSubWebs(web, ref list);
						PopulateListOfDocumentLibraries(web, ref list);
						return (Item[]) list.ToArray(typeof(Item));
					}
				}
				else if (o is SPFolder)
				{
                       SPFolder folder = o as SPFolder;
                       PopulateListOfSubfolders( folder, ref list );
                       PopulateListOfFiles( folder, ref list );
					return (Item[]) list.ToArray(typeof(Item));
				}
				return new Item[0];
			}
		}
		catch (Exception ex)
		{
			Logger.LogException(ex.Message, ex);
			throw;
		}
	}
 internal bool ImportComComponent(string path, OutputMessageCollection outputMessages, string outputDisplayName)
 {
     ComImporter importer = new ComImporter(path, outputMessages, outputDisplayName);
     if (importer.Success)
     {
         ArrayList list = new ArrayList();
         if (this.typeLibs != null)
         {
             list.AddRange(this.typeLibs);
         }
         if (importer.TypeLib != null)
         {
             list.Add(importer.TypeLib);
         }
         this.typeLibs = (TypeLib[]) list.ToArray(typeof(TypeLib));
         list.Clear();
         if (this.comClasses != null)
         {
             list.AddRange(this.comClasses);
         }
         if (importer.ComClasses != null)
         {
             list.AddRange(importer.ComClasses);
         }
         this.comClasses = (ComClass[]) list.ToArray(typeof(ComClass));
     }
     return importer.Success;
 }
    private void reloadBase() {
      this.removeAll ();

      SideMenu = new ArrayList ();

      Window = new ViewWindow ("");
      Window.setWidth (800);
      Window.setHeight (Screen.height - 200);
      Window.setLeft ((Screen.width-800)/2);
      Window.setTop (100);

      this.addComponent (Window);

      SideMenu.Add(new ViewButton("Current State", LoadCurrentState));
      SideMenu.Add(new ViewButton("Space Stations", LoadSpaceStations));
      SideMenu.Add(new ViewButton("Bases", LoadBases));
      SideMenu.Add(new ViewButton("Sat Coverage", LoadSatelliteCoverage));
      SideMenu.Add(new ViewButton("Science Stations", LoadScienceStations));
      SideMenu.Add(new ViewButton("Mining Rigs", LoadMiningRigs));
      SideMenu.Add(new ViewButton("Rovers", LoadRovers));
      SideMenu.Add(new ViewButton("Kerbals", LoadKerbals));
      SideMenu.Add(new ViewButton("Past Reviews", LoadPastReviews));

      for (var i = 0; i < SideMenu.ToArray ().Length; i++) {
        ViewButton Btn = (ViewButton)SideMenu.ToArray () [i];
        Btn.setRelativeTo (Window);
        Btn.setLeft (10);
        Btn.setTop (10 + i * 45);
        Btn.setWidth (120);
        Btn.setHeight (35);
        this.addComponent (Btn);
      }
    }
Example #6
0
 // Methods
 public void ReadTextStream(TextReader tr, StringBuilder errs)
 {
     GcodeOpCode code = null;
     ArrayList list = new ArrayList();
     ArrayList list2 = new ArrayList();
     long linenum = 1L;
     while (true)
     {
         GcodeToken token;
         do
         {
             token = GcodeToken.ReadToken(tr, errs, linenum);
             if (token.ID == 0xffff)
             {
                 if (code != null)
                 {
                     code.Parameter = (GcodeParameter[])list2.ToArray(typeof(GcodeParameter));
                     list.Add(code);
                 }
                 goto Label_0150;
             }
         }
         while (token.ID == 'N');
         if (token.ID == '\n')
         {
             linenum += 1L;
             if (code != null)
             {
                 code.Parameter = (GcodeParameter[])list2.ToArray(typeof(GcodeParameter));
                 list.Add(code);
                 code = null;
             }
         }
         else if ((token.ID == 'G') || (token.ID == 'M'))
         {
             if (code != null)
             {
                 code.Parameter = (GcodeParameter[])list2.ToArray(typeof(GcodeParameter));
                 list.Add(code);
             }
             code = new GcodeOpCode(string.Format("{0}{1:02}", token.ID, token.Value.ToString("00")));
             list2.Clear();
         }
         else
         {
             if (code == null)
             {
                 code = new GcodeOpCode(GcodeOpCode.OpCodes.Unknown);
             }
             GcodeParameter parameter = new GcodeParameter(token);
             if (parameter.OpCode != GcodeOpCode.OpCodes.Unknown)
             {
                 list2.Add(parameter);
             }
         }
     }
     Label_0150:
     this.GCodes = (GcodeOpCode[])list.ToArray(typeof(GcodeOpCode));
 }
    /// <summary>
    /// Sections:
    /// GUIVideoArtistInfo, FanArt, IMDBposter, IMDBActors,
    /// IMPAwardsposter, TMDBPosters, TMDBActorImages
    /// IMDBActorInfoMain, IMDBActorInfoDetails, IMDBActorInfoMovies
    /// </summary>
    /// <param name="section"></param>
    /// <returns></returns>
    public static string[] GetParserStrings(string section)
    {
      ArrayList result = new ArrayList();
      
      try
      {
        string parserIndexFile = Config.GetFile(Config.Dir.Config, "scripts\\VDBParserStrings.xml");
        string parserIndexUrl = @"http://install.team-mediaportal.com/MP1/VDBParserStrings.xml";
        XmlDocument doc = new XmlDocument();
        
        if (!File.Exists(parserIndexFile))
        {
          if (DownloadFile(parserIndexFile, parserIndexUrl) == false)
          {
            string parserIndexFileBase = Config.GetFile(Config.Dir.Base, "VDBParserStrings.xml");

            if (File.Exists(parserIndexFileBase))
            {
              File.Copy(parserIndexFileBase, parserIndexFile, true);
            }
            else
            {
              return result.ToArray(typeof(string)) as string[];
            }
          }
        }

        doc.Load(parserIndexFile);

        if (doc.DocumentElement != null)
        {
          string sec = "/section/" + section;
          XmlNode dbSections = doc.DocumentElement.SelectSingleNode(sec);
          
          if (dbSections == null)
          {
            return result.ToArray(typeof(string)) as string[];
          }

          XmlNodeList parserStrings = dbSections.SelectNodes("string");

          if (parserStrings != null)
          {
            foreach (XmlNode parserString in parserStrings)
            {
              result.Add(parserString.InnerText);
            }
          }
        }
      }
      catch (Exception ex)
      {
        Log.Error(ex.Message);
      }
      return result.ToArray(typeof(string)) as string[];
    }
Example #8
0
 protected void Page_Load(object sender, System.EventArgs e)
 {
     if (!IsPostBack) {
         IList galleries = CmsImageGallery.FindAllRoot();
         ArrayList paths = new ArrayList();
         foreach (CmsImageGallery g in galleries) {
             paths.Add(g.FullPath);
         }
         TextBoxText.ImagesPaths = (string[])paths.ToArray(typeof(string));
         TextBoxText.UploadImagesPaths = (string[])paths.ToArray(typeof(string));
     }
 }
		//rewritten by Corillian so if it doesn't work you know who to yell at ;)
		public void HandlePacket(GameClient client, GSPacketIn packet)
		{
			byte grouped = (byte)packet.ReadByte();
			ArrayList list = new ArrayList();
			if (grouped != 0x00)
			{
				ArrayList groups = GroupMgr.ListGroupByStatus(0x00);
				if (groups != null)
				{
					foreach (Group group in groups)
						if (GameServer.ServerRules.IsAllowedToGroup(group.Leader, client.Player, true))
						{
							list.Add(group.Leader);
						}
				}
			}

			ArrayList Lfg = GroupMgr.LookingForGroupPlayers();

			if (Lfg != null)
			{
				foreach (GamePlayer player in Lfg)
				{
					if (player != client.Player && GameServer.ServerRules.IsAllowedToGroup(client.Player, player, true))
					{
						list.Add(player);
					}
				}
			}

			client.Out.SendFindGroupWindowUpdate((GamePlayer[])list.ToArray(typeof(GamePlayer)));
		}
Example #10
0
		public static PropertyDescriptorCollection GetMethodProperties( object obj )
		{
			System.Type type = obj.GetType();

			if ( obj is MethodPropertyDescriptor.MethodPropertyValueHolder )
			{
				MethodPropertyDescriptor.MethodPropertyValueHolder mobj = obj as MethodPropertyDescriptor.MethodPropertyValueHolder;
//				if ( mobj.Method.IsVoidMethdod )
//					return null;
				return mobj.Method.GetChildProperties( null, null );
			}

			MethodInfo[] methods = type.GetMethods ( BindingFlags.Instance|BindingFlags.InvokeMethod|BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.FlattenHierarchy );

			ArrayList methodDesc = new ArrayList();
			
			for ( int i = 0; i < methods.Length; i++ )
			{
				MethodInfo method = methods[i];
				if ( /*method.IsPublic &&*/ !method.IsSpecialName )
				{
					methodDesc.Add( new MethodPropertyDescriptor( obj, method ) );
				}
			}

			methodDesc.Sort( new MethodNameComparer() );

			MethodPropertyDescriptor[] methodsDesc = (MethodPropertyDescriptor[])methodDesc.ToArray ( typeof(MethodPropertyDescriptor));
			return new PropertyDescriptorCollection(methodsDesc);
		}
        private void EnsureRelevantMethodsAreVirtual(Type service, Type implementation)
        {
            if (service.IsInterface) return;

            MethodInfo[] methods = implementation.GetMethods( 
                BindingFlags.Instance|BindingFlags.Public|BindingFlags.DeclaredOnly );

            ArrayList problematicMethods = new ArrayList();

            foreach( MethodInfo method in methods )
            {
                if (!method.IsVirtual && method.IsDefined( typeof(PermissionAttribute), true ))
                {
                    problematicMethods.Add( method.Name );
                }
            }
			
            if (problematicMethods.Count != 0)
            {
                String[] methodNames = (String[]) problematicMethods.ToArray( typeof(String) );

                String message = String.Format( "The class {0} wants to use security interception, " + 
                    "however the methods must be marked as virtual in order to do so. Please correct " + 
                    "the following methods: {1}", implementation.FullName, String.Join(", ", methodNames) );

                throw new FacilityException(message);
            }
        }
        public void Initialize(bool _includeDrafts)
        {
            // get the list of blogs, determine how many items we will be displaying,
            // and then have that drive the view mode
            string[] blogIds = BlogSettings.GetBlogIds();
            int itemCount = (_includeDrafts ? 1 : 0) + 1 + blogIds.Length;
            _showLargeIcons = itemCount <= 5;

            // configure owner draw
            DrawMode = DrawMode.OwnerDrawFixed;
            SelectionMode = SelectionMode.One;
            HorizontalScrollbar = false;
            IntegralHeight = false;
            ItemHeight = CalculateItemHeight(_showLargeIcons);

            // populate list
            if (_includeDrafts)
                _draftsIndex = Items.Add(new PostSourceItem(new LocalDraftsPostSource(), this));
            _recentPostsIndex = Items.Add(new PostSourceItem(new LocalRecentPostsPostSource(), this));

            ArrayList blogs = new ArrayList();
            foreach (string blogId in BlogSettings.GetBlogIds())
            {
                blogs.Add(new PostSourceItem(Res.Get(StringId.Blog), new RemoteWeblogBlogPostSource(blogId), this));
            }
            blogs.Sort();
            Items.AddRange(blogs.ToArray());
        }
        public string[] GetSelectableNames(string prefixText)
        {
            ArrayList items = new ArrayList();

            Encoding e = Encoding.GetEncoding("shift_jis");
            string str = HttpUtility.UrlEncode(prefixText, e);
            XmlDocument document = new XmlDocument();
            XmlReader reader = XmlReader.Create("http://api.kakaku.com/Ver1/ItemSearch.asp?Keyword=" + str + "&CategoryGroup=ALL&ResultSet=medium&SortOrder=popularityrank&PageNum=1");
            document.Load(reader);
            XmlNodeList nodeList = document.SelectNodes(@"/ProductInfo/Item");
            foreach (XmlNode node in nodeList)
            {
                ProductItem productItem = new ProductItem();
                foreach (XmlNode attrnode in node)
                {
                    switch (attrnode.Name)
                    {
                        case "ProductID":
                            productItem.ProductID = attrnode.InnerText;
                            break;
                        case "ProductName":
                            productItem.ProductName = attrnode.InnerText;
                            break;
                    }
                }

                items.Add(productItem.ProductID + ": " + productItem.ProductName);
            }

            return (String[])items.ToArray(typeof(String));
        }
Example #14
0
        public WebsiteInstaller()
        {
            InstallerInfo info = InstallerInfo.GetInstallerInfo();

            // Add a default one that we can always fall back to
            EventLogInstaller myEventLogInstaller = new EventLogInstaller();
            myEventLogInstaller.Source = InstallerInfo.DefaultEventLogSource;
            Installers.Add(myEventLogInstaller);

            foreach (EventLogInfo source in info.EventLogInfos)
            {
                myEventLogInstaller = new EventLogInstaller();
                myEventLogInstaller.Source = source.Source;
                Installers.Add(myEventLogInstaller);
            }

            foreach (PerformanceCounterCategoryInfo performanceCounter in info.PerformanceCounterCategoryInfos)
            {
                PerformanceCounterInstaller myCounterInstaller = new PerformanceCounterInstaller();
                myCounterInstaller.CategoryHelp = performanceCounter.CategoryHelp;
                myCounterInstaller.CategoryName = performanceCounter.CategoryName;
                ArrayList counters = new ArrayList();
                foreach (CounterCreationDataInfo creationDataInfo in performanceCounter.CounterCreationDataInfos)
                    counters.Add(new CounterCreationData(creationDataInfo.CounterName, creationDataInfo.CounterHelp,
                                                         creationDataInfo.CounterType));

                myCounterInstaller.Counters.AddRange(
                    (CounterCreationData[]) counters.ToArray(typeof (CounterCreationData)));
                Installers.Add(myCounterInstaller);
            }
        }
	private void SelectLightmapUsers(object userData, string[] options, int selected)
	{
		int num = (int)userData;
		ArrayList arrayList = new ArrayList();
		MeshRenderer[] array = UnityEngine.Object.FindObjectsOfType(typeof(MeshRenderer)) as MeshRenderer[];
		MeshRenderer[] array2 = array;
		for (int i = 0; i < array2.Length; i++)
		{
			MeshRenderer meshRenderer = array2[i];
			if (meshRenderer != null && meshRenderer.lightmapIndex == num)
			{
				arrayList.Add(meshRenderer.gameObject);
			}
		}
		Terrain[] array3 = UnityEngine.Object.FindObjectsOfType(typeof(Terrain)) as Terrain[];
		Terrain[] array4 = array3;
		for (int j = 0; j < array4.Length; j++)
		{
			Terrain terrain = array4[j];
			if (terrain != null && terrain.lightmapIndex == num)
			{
				arrayList.Add(terrain.gameObject);
			}
		}
		Selection.objects = (arrayList.ToArray(typeof(UnityEngine.Object)) as UnityEngine.Object[]);
	}
        public DateTime[] GetTipTimes(string inFile)
        {
            ArrayList tipTimes = new ArrayList();
            //open file

            if (!File.Exists(inFile))
            {
                throw new Exception("file doesn't exist");
            }

            // Open the file to read from.for each line, add tip time to an array
            using (StreamReader sr = File.OpenText(inFile))
            {
                string s = "";
                while ((s = sr.ReadLine()) != null)
                {
                    if(DateIsValid(s))
                    {
                        tipTimes.Add(DateTime.Parse(s));
                    }
                    else
                        Debug.WriteLine(s);
                }
            }

            return tipTimes.ToArray(Type.GetType("System.DateTime")) as DateTime [];
        }
Example #17
0
        public static string[] GetMXRecords(string domain)
        {
            IntPtr ptr1 = IntPtr.Zero;
            IntPtr ptr2 = IntPtr.Zero;
            MXRecord recMx;

            if (Environment.OSVersion.Platform != PlatformID.Win32NT)
                throw new NotSupportedException();

            ArrayList list1 = new ArrayList();
            int num1 = DnsMx.DnsQuery(ref domain, QueryTypes.DNS_TYPE_MX, QueryOptions.DNS_QUERY_BYPASS_CACHE, 0, ref ptr1, 0);
            if (num1 != 0)
                throw new Win32Exception(num1);

            for (ptr2 = ptr1; !ptr2.Equals(IntPtr.Zero); ptr2 = recMx.pNext)
            {
                recMx = (MXRecord)Marshal.PtrToStructure(ptr2, typeof(MXRecord));
                if (recMx.wType == 15)
                {
                    string text1 = Marshal.PtrToStringAuto(recMx.pNameExchange);
                    list1.Add(text1);
                }
            }

            DnsMx.DnsRecordListFree(ptr1, 0);
            return (string[])list1.ToArray(typeof(string));
        }
        /// <summary>
        /// Parse and filter the supplied modifications.  The position of each modification in the list is used as the ChangeNumber.
        /// </summary>
        /// <param name="history"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <returns></returns>
        public Modification[] Parse(TextReader history, DateTime from, DateTime to)
        {
            StringReader sr = new StringReader(string.Format(@"<ArrayOfModification xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">{0}</ArrayOfModification>"
                , history.ReadToEnd()));

            XmlSerializer serializer = new XmlSerializer(typeof(Modification[]));
            Modification[] mods;
            try
            {
                mods = (Modification[])serializer.Deserialize(sr);
            }
            catch (Exception ex)
            {
                throw new CruiseControlException("History Parsing Failed", ex);
            }

            ArrayList results = new ArrayList();
            int change = 0;
            foreach (Modification mod in mods)
            {
                change++;
                mod.ChangeNumber = change;
                if ((mod.ModifiedTime >= from) & (mod.ModifiedTime <= to))
                {
                    results.Add(mod);
                }
            }
            return (Modification[])results.ToArray(typeof(Modification));
        }
Example #19
0
 /// <summary>
 /// Prepare realtime inputs, and place them in an understandable one jagged input neuron array.
 /// you can use this method if you have many inputs and need to format them as inputs with a specified "window"/input size.
 /// You can add as many inputs as wanted to this input layer (parametrable inputs).
 /// </summary>
 /// <param name="inputsize">The inputsize.</param>
 /// <param name="firstinputt">The firstinputt.</param>
 /// <returns>a ready to use jagged array with all the inputs setup.</returns>
 public static double[][] AddInputs(int inputsize, params double[][] firstinputt)
 {
     ArrayList arlist = new ArrayList(4);
     ArrayList FirstList = new ArrayList();
     List<double> listused = new List<double>();
     int lenghtofArrays = firstinputt[0].Length;
     //There must be NO modulo...or the arrays would not be divisile by this input size.
     if (lenghtofArrays % inputsize != 0)
         return null;
     //we add each input one , after the other in a list of doubles till we reach the input size
     for (int i = 0; i < lenghtofArrays; i++)
     {
         for (int k = 0; k < firstinputt.Length; k++)
         {
             if (listused.Count < inputsize * firstinputt.Length)
             {
                 listused.Add(firstinputt[k][i]);
                 if (listused.Count == inputsize * firstinputt.Length)
                 {
                     FirstList.Add(listused.ToArray());
                     listused.Clear();
                 }
             }
         }
     }
     return (double[][])FirstList.ToArray(typeof(double[]));
 }
        public override fsResult TryDeserialize(fsData data, ref object instance, Type storageType) {
            var result = fsResult.Success;

            // Verify that we actually have an List
            if ((result += CheckType(data, fsDataType.Array)).Failed) {
                return result;
            }

            Type elementType = storageType.GetElementType();

            var serializedList = data.AsList;
            var list = new ArrayList(serializedList.Count);
            int existingCount = list.Count;

            for (int i = 0; i < serializedList.Count; ++i) {
                var serializedItem = serializedList[i];
                object deserialized = null;
                if (i < existingCount) deserialized = list[i];

                var itemResult = Serializer.TryDeserialize(serializedItem, elementType, ref deserialized);
                result.AddMessages(itemResult);
                if (itemResult.Failed) continue;

                if (i < existingCount) list[i] = deserialized;
                else list.Add(deserialized);
            }

            instance = list.ToArray(elementType);
            return result;
        }
Example #21
0
        public static string Text_Decryption(string text, int bits, string encryption_key)
        {
            string result = String.Empty;
            ArrayList list = new ArrayList();

            try
            {
                RSACryptoServiceProvider rsacsp = new RSACryptoServiceProvider(bits);
                rsacsp.FromXmlString(encryption_key);
                int blockSizeBase64 = (bits / 8 % 3 != 0) ?  (((bits / 8) / 3) * 4) + 4 : ((bits / 8) / 3) * 4;
                int iterations = text.Length / blockSizeBase64;

                for (int i = 0; i < iterations; i++)
                {
                    Byte[] encrypted_bytes = Convert.FromBase64String(text.Substring(blockSizeBase64 * i, blockSizeBase64));
                    Array.Reverse(encrypted_bytes);
                    list.AddRange(rsacsp.Decrypt(encrypted_bytes, true));
                }

            }
            catch (Exception e)
            {
                result = "<Error>" + e.Message + "</Error>";
            }

            result = Encoding.UTF32.GetString((Byte[])list.ToArray(typeof(Byte)));

            return result;
        }
Example #22
0
 public static HtmlElement[] GetElements(string text)
 {
     ArrayList list = new ArrayList();
     int startIndex = 0;
     int index = 0;
     int num3 = 0;
     while (true)
     {
         num3 = index;
         startIndex = text.IndexOf('<', index);
         if (startIndex == -1)
         {
             list.Add(new HtmlElement(text.Substring(num3), ElementType.Text, null));
             break;
         }
         index = text.IndexOf('>', startIndex + 1);
         if (index == -1)
         {
             list.Add(new HtmlElement(text.Substring(num3), ElementType.Text, null));
             break;
         }
         if (startIndex != num3)
         {
             list.Add(new HtmlElement(text.Substring(num3, startIndex - num3), ElementType.Text, null));
         }
         index++;
         list.Add(Parse(text.Substring(startIndex, index - startIndex)));
     }
     return (HtmlElement[]) list.ToArray(typeof(HtmlElement));
 }
        // Methods
        public new void Execute(CopyItemsArgs args)
        {
            Event.RaiseEvent("item:bucketing:cloning", args, this);
            Assert.ArgumentNotNull(args, "args");
            var items = GetItems(args);
            if (args.IsNotNull())
            {
                var itemId = args.Parameters["destination"];
                if (itemId.IsNotNull())
                {
                    var database = GetDatabase(args);
                    if (database.GetItem(itemId).IsBucketItemCheck())
                    {
                        var list = new ArrayList();
                        foreach (var item3 in from item2 in items
                                              where item2.IsNotNull()
                                              let item = BucketManager.CreateAndReturnDateFolderDestination(database.GetItem(itemId), item2)
                                              let copyOfName = ItemUtil.GetCopyOfName(item, item2.Name)
                                              select item2.CloneTo(item, copyOfName, true))
                        {
                            list.Add(item3);
                        }

                        args.Copies = list.ToArray(typeof(Item)) as Item[];
                        Event.RaiseEvent("item:bucketing:cloned", args, this);
                        args.AbortPipeline();
                    }
                }
            }
        }
	/// <summary>
	/// parse the config section
	/// </summary>
	/// <param name="parent"></param>
	/// <param name="configContext"></param>
	/// <param name="section"></param>
	/// <returns>an array of <see cref="MemCacheConfig"/> objects</returns>
	public object Create(object parent, object configContext, XmlNode section)
	{
		var configs = new ArrayList();
		if (section != null)
		{
			XmlNodeList nodes = section.SelectNodes("memcached");
			foreach (XmlNode node in nodes)
			{
				XmlAttribute h = node.Attributes["host"];
				XmlAttribute p = node.Attributes["port"];
				XmlAttribute w = node.Attributes["weight"];
				if (h == null || p == null)
				{
					if (log.IsWarnEnabled)
					{
						log.Warn("incomplete node found - each memcached element must have a 'host' and a 'port' attribute.");
					}
					continue;
				}
				string host = h.Value;
				int port = ((string.IsNullOrEmpty(p.Value)) ? 0 : Convert.ToInt32(p.Value));
				int weight = ((w == null || string.IsNullOrEmpty(w.Value)) ? 0 : Convert.ToInt32(w.Value));
				configs.Add(new MemCacheConfig(host, port, weight));
			}
		}
		return configs.ToArray(typeof (MemCacheConfig));
	}
		public static string[] Split( string src, char delimiter, params char[] quotedelims )
		{
			ArrayList		strings = new ArrayList();
			StringBuilder	sb = new StringBuilder();
			ArrayList		ar = new ArrayList(quotedelims);
			char			quote_open = Char.MinValue;

			foreach (char c in src) 
			{
				if (c == delimiter && quote_open == Char.MinValue) 
				{
					strings.Add( sb.ToString() );
					sb.Remove( 0, sb.Length );
				}
					
				else if (ar.Contains(c)) 
				{
					if (quote_open == Char.MinValue)
						quote_open = c;
					else if (quote_open == c)
						quote_open = Char.MinValue;
					sb.Append(c);
				}
				else
					sb.Append( c );
			}

			if (sb.Length > 0)
				strings.Add( sb.ToString());

			return (string[])strings.ToArray(typeof(string));
		}
Example #26
0
        private static void LoadLocations()
        {
            string filePath = Path.Combine(Core.BaseDirectory, "Data/treasure.cfg");

            ArrayList list = new ArrayList();
            ArrayList havenList = new ArrayList();

            if (File.Exists(filePath))
            {
                using (StreamReader ip = new StreamReader(filePath))
                {
                    string line;

                    while ((line = ip.ReadLine()) != null)
                    {
                        try
                        {
                            string[] split = line.Split(' ');

                            int x = Convert.ToInt32(split[0]), y = Convert.ToInt32(split[1]);

                            Point2D loc = new Point2D(x, y);
                            list.Add(loc);
                        }
                        catch
                        {
                        }
                    }
                }
            }

            m_Locations = (Point2D[])list.ToArray(typeof(Point2D));
        }
 public static string[] AllSites()
 {
     ArrayList allSites = new ArrayList();
     allSites.AddRange(BatchSearchSites);
     string[] allSitesArray = (string[]) allSites.ToArray(typeof (string));
     return allSitesArray;
 }
 ///<summary>
 ///</summary>
 ///<param name="args"></param>
 public CommandLine(string[] args)
 {
     ArrayList list = new ArrayList();
     for (int i = 0; i < args.Length; i++)
     {
         char ch = args[i][0];
         if ((ch != '/') && (ch != '-'))
         {
             list.Add(args[i]);
         }
         else
         {
             int index = args[i].IndexOf(':');
             if (index == -1)
             {
                 string strA = args[i].Substring(1);
                 if ((string.Compare(strA, "help", StringComparison.OrdinalIgnoreCase) == 0) || strA.Equals("?"))
                 {
                     _showHelp = true;
                 }
                 else
                 {
                     Options[strA] = string.Empty;
                 }
             }
             else
             {
                 Options[args[i].Substring(1, index - 1)] = args[i].Substring(index + 1);
             }
         }
     }
     _arguments = (string[]) list.ToArray(typeof (string));
 }
Example #29
0
        public static Device[] Scan(OneWire ow, params Family[] includeFamilies)
        {
            var addr = new byte[8];
            var list = new ArrayList();
            var all = false;
            var devs = ow.FindAllDevices();

            if (includeFamilies != null)
            {
                foreach (var f in includeFamilies)
                {
                    if (f == Family.Unknown)
                        all = true;
                }
            }

            foreach (byte[] da in devs)
            {
                if (includeFamilies == null || includeFamilies.Length == 0 || all)
                {
                    list.Add(new Device(da));
                }
                else
                {
                    foreach (var f in includeFamilies)
                    {
                        if (addr[0] == (byte)f)
                            list.Add(new Device(da));
                    }
                }
            }

            return (Device[])list.ToArray(typeof(Device));
        }
Example #30
0
		public IList FindProcessInstances(DateTime startedAfter, DateTime startedBefore, String initiatorActorId, String actorId, Int64 processDefinitionId, Relations relations, DbSession dbSession)
		{
			IList processInstances = null;
			String query = queryFindAllProcessInstances;
			ArrayList parameters = new ArrayList();
			ArrayList types = new ArrayList();

			if (startedAfter != DateTime.MinValue)
			{
				query += "and pi.StartNullable > ? ";
				parameters.Add(startedAfter);
				types.Add(DbType.DATE);
			}

			if (startedBefore != DateTime.MinValue)
			{
				query += "and pi.StartNullable < ? ";
				parameters.Add(startedBefore);
				types.Add(DbType.DATE);
			}

			if (initiatorActorId != null && initiatorActorId != "")
			{
				query += "and pi.InitiatorActorId = ? ";
				parameters.Add(initiatorActorId);
				types.Add(DbType.STRING);
			}

			if (actorId != null && actorId != "")
			{
				query += "and f.ActorId = ? ";
				parameters.Add(actorId);
				types.Add(DbType.STRING);
			}

			if (processDefinitionId != 0)
			{
				query += "and pi.ProcessDefinition.Id = ? ";
				parameters.Add(processDefinitionId);
				types.Add(DbType.LONG);
			}

			query += "order by pi.StartNullable desc";

			log.Debug("query for searching process instances : '" + query + "'");

			Object[] parameterArray = parameters.ToArray();
			IType[] typeArray = (IType[]) types.ToArray(typeof (IType));

			processInstances = dbSession.Find(query, parameterArray, typeArray);

			if (relations != null)
			{
				relations.Resolve(processInstances);
			}

			log.Debug("process instances : '" + processInstances + "'");

			return processInstances;
		}