/// <summary>
        ///     Constructor taking the path to the configuration file. 
        ///     Starts the lidgren server to start listening for connections, and 
        ///     initializes all data structres and such.
        /// </summary>
        /// <param name="configpath"></param>
        public RegionServer(string configpath)
        {
            //Load this region server's junk from xml
            XmlSerializer deserializer = new XmlSerializer(typeof(RegionConfig));
            RegionConfig regionconfig = (RegionConfig)deserializer.Deserialize(XmlReader.Create(configpath));

            //Create the server
            var config = new NetPeerConfiguration(regionconfig.ServerName);
            config.Port = regionconfig.ServerPort;
            LidgrenServer = new NetServer(config);
            LidgrenServer.Start();

            //Initizlie our data structures
            Characters = new Dictionary<Guid, Character>();
            UserIdToMasterServer = new Dictionary<Guid, NetConnection>();
            TeleportEnters = new List<TeleportEnter>(regionconfig.TeleportEnters);
            TeleportExits = new List<TeleportExit>(regionconfig.TeleportExits);
            ItemSpawns = new List<ItemSpawn>(regionconfig.ItemSpawns);
            ItemSpawnIdGenerator = new UniqueId();
            ItemSpawnsWaitingForSpawn = new Dictionary<ItemSpawn, DateTime>();

            foreach(ItemSpawn spawn in ItemSpawns)
                ItemSpawnIdGenerator.RegisterId(spawn.Id);

            RegionId = regionconfig.RegionId;
        }

		/// <summary>
		/// Attempts to parse an atom token as a set of UIDs.
		/// </summary>
		/// <returns><c>true</c> if the UIDs were successfully parsed, otherwise <c>false</c>.</returns>
		/// <param name="atom">The atom string.</param>
		/// <param name="uids">The UIDs.</param>
		public static bool TryParseUidSet (string atom, out UniqueId[] uids)
		{
			var ranges = atom.Split (new [] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			var list = new List<UniqueId> ();

			uids = null;

			for (int i = 0; i < ranges.Length; i++) {
				var minmax = ranges[i].Split (':');
				uint min;

				if (!uint.TryParse (minmax[0], out min) || min == 0)
					return false;

				if (minmax.Length == 2) {
					uint max;

					if (!uint.TryParse (minmax[1], out max) || max == 0)
						return false;

					for (uint uid = min; uid <= max; uid++)
						list.Add (new UniqueId (uid));
				} else if (minmax.Length == 1) {
					list.Add (new UniqueId (min));
				} else {
					return false;
				}
			}

			uids = list.ToArray ();

			return true;
		}

 protected ManageableSecurity(string name, string securityType, UniqueId uniqueId, ExternalIdBundle identifiers)
 {
     _name = name;
     _securityType = string.Intern(securityType); // Should be a small static set
     _uniqueId = uniqueId;
     _identifiers = identifiers;
 }

 public ChangeEvent(ChangeType type, UniqueId beforeId, UniqueId afterId, Instant versionInstant)
 {
     _type = type;
     _beforeId = beforeId;
     _afterId = afterId;
     _versionInstant = versionInstant;
 }

 internal PortfolioNode(UniqueId uniqueId, string name, IList<PortfolioNode> subNodes, IList<IPosition> positions)
 {
     _uniqueId = uniqueId;
     _name = name;
     _subNodes = subNodes;
     _positions = positions;
 }

 public SimplePosition(UniqueId identifier, decimal quantity, ExternalIdBundle securityKey, IList<ITrade> trades)
 {
     _securityKey = securityKey;
     _trades = trades;
     _identifier = identifier;
     _quantity = quantity;
 }

 public SimpleTrade(UniqueId uniqueId, DateTimeOffset tradeDate, ExternalIdBundle securityKey, CounterpartyImpl counterparty, decimal quantity)
 {
     _uniqueId = uniqueId;
     _quantity = quantity;
     _securityKey = securityKey;
     _counterparty = counterparty;
     _tradeDate = tradeDate;
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="T:MailKit.Search.UidSearchQuery"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new unique identifier-based search query.
		/// </remarks>
		/// <param name="uid">The unique identifier to match against.</param>
		/// <exception cref="System.ArgumentException">
		/// <paramref name="uid"/> is an invalid unique identifier.
		/// </exception>
		public UidSearchQuery (UniqueId uid) : base (SearchTerm.Uid)
		{
			if (!uid.IsValid)
				throw new ArgumentException ("Cannot search for an invalid unique identifier.", nameof (uid));

			Uids = new UniqueIdSet (SortOrder.Ascending);
			Uids.Add (uid);
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="Deflect"/> class.
        /// </summary>
        /// <param name="id">Channel id</param>
        /// <param name="address">Sip address to deflect to</param>
        public Deflect(UniqueId id, SipAddress address)
        {
            if (id == null) throw new ArgumentNullException("id");
            if (address == null) throw new ArgumentNullException("address");

            _id = id;
            _address = address;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="StartRecording"/> class.
 /// </summary>
 /// <param name="id">The id.</param>
 /// <param name="path">FreeSwitch relative path (directory + filename).</param>
 public StartRecording(UniqueId id, string path)
 {
     if (id == null) throw new ArgumentNullException("id");
     if (path == null) throw new ArgumentNullException("path");
     _id = id;
     _path = path;
     RecordingLimit = TimeSpan.MinValue;
 }

 public YieldCurveDefinitionDocument Get(UniqueId uniqueId)
 {
     var resp = _restTarget.Resolve("definitions", uniqueId.ToString()).Get<YieldCurveDefinitionDocument>();
     if (resp == null || resp.UniqueId == null || resp.YieldCurveDefinition == null)
     {
         throw new ArgumentException("Not found", "uniqueId");
     }
     return resp;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="SetVariable"/> class.
 /// </summary>
 /// <param name="id">Channel id.</param>
 /// <param name="name">Variable name as declared by FreeSWITCH.</param>
 /// <param name="value">Variable value, <see cref="string.Empty"/> if you which to unset it.</param>
 public SetVariable(UniqueId id, string name, string value)
 {
     if (id == null) throw new ArgumentNullException("id");
     if (name == null) throw new ArgumentNullException("name");
     if (value == null) throw new ArgumentNullException("value");
     _channelId = id;
     _name = name;
     _value = value;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Sleep"/> class.
        /// </summary>
        /// <param name="id">Channel id.</param>
        /// <param name="duration">The duration.</param>
        public Sleep(UniqueId id, TimeSpan duration)
        {
            if (id == null) throw new ArgumentNullException("id");
            if (_duration == TimeSpan.MinValue)
                throw new ArgumentException("Duration must be larger than 0 ms.", "duration");

            _id = id;
            _duration = duration;
        }

 public PortfolioDocument Get(UniqueId uniqueId)
 {
     ArgumentChecker.NotNull(uniqueId, "uniqueId");
     var resp = _restTarget.Resolve("portfolios").Resolve(uniqueId.ObjectID.ToString()).Get<PortfolioDocument>();
     if (resp == null || resp.UniqueId == null || resp.Portfolio == null)
     {
         throw new ArgumentException("Not found", "uniqueId");
     }
     return resp;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="SendMsg"/> class.
        /// </summary>
        /// <param name="id">Channel UUID.</param>
        /// <param name="callCommand">The call command.</param>
        protected SendMsg(UniqueId id, string callCommand)
        {
            if (id == null)
                throw new ArgumentNullException("id");
            if (string.IsNullOrEmpty(callCommand))
                throw new ArgumentNullException("callCommand");

            _callCommand = callCommand;
            _id = id;
        }

		public void TestFormattingNonSequentialUids ()
		{
			UniqueId[] uids = new UniqueId[] {
				new UniqueId (1), new UniqueId (3), new UniqueId (5),
				new UniqueId (7), new UniqueId (9)
			};
			string expect = "1,3,5,7,9";
			string actual;

			actual = ImapUtils.FormatUidSet (uids);
			Assert.AreEqual (expect, actual, "Formatting a non-sequential list of uids.");
		}

        internal PixelShader(SlimDX.Direct3D11.PixelShader pixelShader)
        {
            #if ASSERT
            if (pixelShader == null)
            {
                throw new ArgumentNullException("pixelShader");
            }
            #endif

            resourceOwner = false;
            this.pixelShader = pixelShader;
            uniqueId = new UniqueId<PixelShader>();
        }

        internal Texture2d(SlimDX.Direct3D11.Device device, string fileName)
        {
            #if ASSERT
            if (device == null)
            {
                throw new ArgumentNullException("device");
            }
            #endif

            texture2d = SlimDX.Direct3D11.Texture2D.FromFile(device, fileName);
            shaderResourceView = new SlimDX.Direct3D11.ShaderResourceView(device, texture2d);
            uniqueId = new UniqueId<Texture2d>();
        }

		public void TestFormattingSimpleUidRange ()
		{
			UniqueId[] uids = new UniqueId[] {
				new UniqueId (1), new UniqueId (2), new UniqueId (3),
				new UniqueId (4), new UniqueId (5), new UniqueId (6),
				new UniqueId (7), new UniqueId (8), new UniqueId (9)
			};
			string expect = "1:9";
			string actual;

			actual = ImapUtils.FormatUidSet (uids);
			Assert.AreEqual (expect, actual, "Formatting a simple range of uids failed.");
		}

        internal RenderTarget(SlimDX.Direct3D11.RenderTargetView renderTargetView)
        {
            #if ASSERT
            if (renderTargetView == null)
            {
                throw new ArgumentNullException("renderTargetView");
            }
            #endif

            this.renderTargetView = renderTargetView;
            resourceOwner = false;
            uniqueId = new UniqueId<RenderTarget>();
        }