static public string Convert(double bytes, double reference, DirectionType direction, string format)
 {
     ConversionType conversionType;
     conversionType = GetConversionType(reference);
     conversionType = MoveDirection(conversionType, direction);
     return Convert(bytes, conversionType, format);
 }

 public PacketLogEntry(DateTime time, DirectionType direction, string address, byte[] data)
 {
     Time = time;
     Direction = direction;
     Address   = address;
     Data      = data;
 }

    // ------------------------------------------------------------------------------------ //
    private void changeDirectionRandom()
    {
        float angle = 0;

        if (currentDirectionType == DirectionType.Forward)
        {
            if (Probability.getProbability(50)) {
                currentDirectionType = DirectionType.Left;
                angle = rotateAngle;
            }
            else {
                currentDirectionType = DirectionType.Right;
                angle = -rotateAngle;
            }
        }
        else if (currentDirectionType == DirectionType.Left)
        {
            currentDirectionType = DirectionType.Forward;
            angle = -rotateAngle;
        }
        else if (currentDirectionType == DirectionType.Right)
        {
            currentDirectionType = DirectionType.Forward;
            angle = rotateAngle;
        }

        rotateUnit(angle);
    }

        public SortNode(XmlNode xmlNode, InternalScriptSettings settings)
            : base(xmlNode, settings)
        {
            // Load attributes
            foreach (XmlAttribute attr in xmlNode.Attributes) {
                switch (attr.Name) {
                    case "direction":
                        string dirStr = attr.Value.ToLower().Trim();
                        if (dirStr == "desc" || dirStr == "descending")
                            direction = DirectionType.DESCENDING;
                        else if (dirStr == "asc" || dirStr == "ascending")
                            direction = DirectionType.ASCENDING;
                        else {
                            logger.Error("Invalid sort direction on: " + xmlNode.OuterXml);
                        }
                        break;
                    case "by":
                        sortBy = attr.Value;
                        break;

                }
            }

             // Validate BY attribute
            if (sortBy == null) {
                logger.Error("Missing BY attribute on: " + xmlNode.OuterXml);
                loadSuccess = false;
                return;
            }
        }

        UnitsType m_Units = UnitsType.Celsius; // this defines the units of the new input temperatures, but our calculations will be in Celcius

        #endregion Fields

        #region Constructors

        // constructor
        public Thermometer(UnitsType units, DirectionType direction, double threshold, double hysterisis)
        {
            Units = units;
            Direction = direction;
            Threshold = threshold;
            HysterisisThreshold = hysterisis;
        }

 public PacketLogEntry(DateTime time, TransportProtocol protocol, DirectionType direction, DhtAddress address, byte[] data)
 {
     Time = time;
     Protocol  = protocol;
     Direction = direction;
     Address   = address;
     Data      = data;
 }

        public Tree(int x, int y)
        {
            base.Initialize(x, y, 1, 1, Texture);

            direction = DirectionType.South;

            Name = "Tree";
        }

 public HttpNetworkStream(DirectionType direction, Socket socket,
     System.IO.FileAccess fileAccess, bool ownsSocket)
 {
     Direction = direction;
     _socket = socket;
     _stream = new PrependableNetworkStream(socket, fileAccess, ownsSocket);
     _unknownContentLength = true;
 }

        public void ResetCounter(StateType state, DirectionType direction)
        {
            if (direction != Direction) {
                _counter = 1000;
                _animationIndex = 0;
            }

            State = state;
            Direction = direction;
        }

        public TransitDescription(Route route, DirectionType transitType)
        {
            if (route == null)
            {
                throw new ArgumentNullException("route");
            }

            this.TransitType = transitType;
            this.StartLocation = route.RouteLegs[0].ActualStart.AsGeoCoordinate();
            this.EndLocation = route.RouteLegs[0].ActualEnd.AsGeoCoordinate();
            this.TravelDuration = route.TravelDuration;
            this.ArrivalTime = route.RouteLegs[0].EndTime.ToShortTimeString();
            this.DepartureTime = route.RouteLegs[0].StartTime.ToShortTimeString();

            // TODO: need to add endpoint to the step list?
            this.ItinerarySteps = new ObservableCollection<ItineraryStep>();
            var stepNumber = 0;
            foreach (var topLeg in route.RouteLegs[0].ItineraryItems)
            {
                this.ItinerarySteps.Add(new ItineraryStep(topLeg, ++stepNumber));

                // calculate the walking start and end times
                if (this.ItinerarySteps[stepNumber - 1].IconType == "Walk")
                {
                    if (stepNumber == 1)
                    {
                        // WalkOnly directions needs to be set a default time. Using current time
                        this.ItinerarySteps[stepNumber - 1].StartTime = this.TransitType == DirectionType.WalkOnly ? DateTime.Now : route.RouteLegs[0].StartTime;
                    }
                    else
                    {
                        this.ItinerarySteps[stepNumber - 1].StartTime = this.ItinerarySteps[stepNumber - 2].EndTime;
                    }

                    this.ItinerarySteps[stepNumber - 1].EndTime = this.ItinerarySteps[stepNumber - 1].StartTime + TimeSpan.FromSeconds(topLeg.TravelDuration);
                }
            }

            this.ItinerarySteps[0].StepType = ItineraryStep.ItineraryStepType.FirstStep;
            this.ItinerarySteps[this.ItinerarySteps.Count - 1].StepType = ItineraryStep.ItineraryStepType.LastStep;

            // check the first and last step for generic strings to replace
            // TODO: need a better place to put this
            this.ItinerarySteps[0].Instruction = this.ItinerarySteps[0].Instruction.Replace(SR.SourceLocation, ViewModelLocator.MainMapViewModelStatic.StartLocationText);
            this.ItinerarySteps[this.ItinerarySteps.Count - 1].Instruction = this.ItinerarySteps[this.ItinerarySteps.Count - 1].Instruction.Replace(SR.DestinationLocation, ViewModelLocator.MainMapViewModelStatic.EndLocationText);

            this.PathPoints = route.RoutePaths[0].Line;

            this.MapView = route.BoundingBox.AsLocationRect();
        }

 public static DirectionType getRight(DirectionType d)
 {
     switch (d) {
     case DirectionType.NORTH: return DirectionType.NORTHEAST;
     case DirectionType.NORTHEAST: return DirectionType.EAST;
     case DirectionType.EAST : return DirectionType.SOUTHEAST;
     case DirectionType.SOUTHEAST : return DirectionType.SOUTH;
     case DirectionType.SOUTH : return DirectionType.SOUTHWEST;
     case DirectionType.SOUTHWEST : return DirectionType.WEST;
     case DirectionType.WEST : return DirectionType.NORTHWEST;
     case DirectionType.NORTHWEST : return DirectionType.NORTH;
     default : return DirectionType.NORTH;
     }
 }

        public Person(int x, int y)
            : base(x, y, 1, 1, texturesMap[ProfessionType.Worker])
        {
            age = 0;
            education = 0;
            gender = GenderType.Male;
            health = HEALTH_MAX;
            profession = ProfessionType.Worker;
            Random random = new Random();
            direction = (DirectionType)(random.Next() % (int)DirectionType.SIZE);
            remainingMovement = movementRange = 36;
            BlocksMovement = false;

            Name = "Person";
        }

			private IImageManager GetDirectionalImageManager(IImageManager imageManager, DirectionType directionType)
			{
				//TODO: Compressed and PDF files need to be able to find each other for the case of a folder containing both .pdf and .cbr

				IImageManager nextImageManager = null;
				var path = imageManager.Location;
				int directionOffset = directionType == DirectionType.Next ? 1 : -1;

				//TODO: code for CompressedFileImageManager and FolderImageManager is virtually identical. Consolidate!
				if ((imageManager is CompressedFileImageManager) || (imageManager is PDFImageManager))
				{
					var fileName = Path.GetFileName(path).ToLower();
					var fileInfo = new FileInfo(path);
					var supportFileTypes = imageManager is CompressedFileImageManager
						? CompressedFileImageManager.SUPPORTED_FILETYPES
						: PDFImageManager.SUPPORTED_FILETYPES;

					var fileInfos = fileInfo.Directory.GetFiles()
						.Where(x => supportFileTypes.Contains(x.Extension.ToLower()))
						.OrderBy(x => x.Name, Utility.NaturalStringComparer)
						.ToList();

					var foundFileIndex = fileInfos.FindIndex(x => x.Name.ToLower() == fileName) + directionOffset;
					if ((foundFileIndex < fileInfos.Count) && (foundFileIndex > -1))
					{
						imageManager.Dispose();
						nextImageManager = this.Load(fileInfos[foundFileIndex].FullName);
					}
				}
				else if (imageManager is FolderImageManager)
				{
					DirectoryInfo directoryInfo = new DirectoryInfo(path);
					var directoryName = directoryInfo.Name.ToLower();
					var directoryInfos = directoryInfo.Parent.GetDirectories()
						.OrderBy(x => x.Name, Utility.NaturalStringComparer)
						.ToList();

					var foundDirectoryIndex = directoryInfos.FindIndex(x => x.Name.ToLower() == directoryName) + directionOffset;
					if ((foundDirectoryIndex < directoryInfos.Count) && (foundDirectoryIndex > -1))
					{
						imageManager.Dispose();
						nextImageManager = this.Load(directoryInfos[foundDirectoryIndex].FullName);
					}
				}

				return nextImageManager;
			}

        public void Initialize(string[] parameters)
        {
            if (parameters.Contains("Origin"))
                hasOrigin = true;

            if (parameters.Contains("Direction"))
                direction = DirectionType.Direction;
            else if (parameters.Contains("Angle"))
                direction = DirectionType.Angle;

            if (parameters.Contains("Speed"))
                hasSpeed = true;

            foreach (string param in parameters)
                if (param == "Param")
                    paramCount++;
        }

 public InputOrder(
     string brokerID,
     string investorID,
     DirectionType direction,
     OffsetFlag offsetFlag,
     string instrumentID,
     double price,
     int volume,
     string groupID)
 {
     this.BrokerID = brokerID;
     this.InvestorID = investorID;
     this.Direction = direction;
     this.OffsetFlag = offsetFlag;
     this.InstrumentID = instrumentID;
     this.Price = price;
     this.Volume = volume;
     this.GroupID = groupID;
 }

    public override sealed void onUnitCollision(GameObject other)
    {
        base.onUnitCollision(other);

        if (other.tag.Equals("LevelBorder"))
        {
            float angle = 0;

            if (currentDirectionType == DirectionType.Left) {
                currentDirectionType = DirectionType.Right;
                angle = -rotateAngle*2;
            }
            else if (currentDirectionType == DirectionType.Right) {
                currentDirectionType = DirectionType.Left;
                angle = rotateAngle*2;
            }

            rotateUnit(angle);
        }
    }

 public Tile getAdjascentTile(Tile t, DirectionType dir)
 {
     Tile retval = null;
     switch(dir)
     {
         case DirectionType.West:
             retval = getTileFromLocation(t.x, t.y - 1);
             break;
         case DirectionType.East:
             retval = getTileFromLocation(t.x, t.y + 1);
             break; 
         case DirectionType.North:
             retval = getTileFromLocation(t.x - 1, t.y);
             break;
         case DirectionType.South:
             retval = getTileFromLocation(t.x + 1, t.y);
             break;
         default: break;
     }
     return retval;
 }

    private void moveCube()
    {
        float testCubeXPos = _testCube.transform.position.x;
        if (_dirType == DirectionType.Left){
            _testCube.transform.Translate(Vector3.left * 0.5f);
        } else if (_dirType == DirectionType.Right){
            _testCube.transform.Translate(Vector3.right * 0.5f);
        }

        if (testCubeXPos < -3){
            TestSignals.changeScaleSignal.dispatch();
            _dirType = DirectionType.Right;
        }

        if (testCubeXPos > 3) {
            TestSignals.normalScaleSignal.dispatch();
            _dirType = DirectionType.Left;

        }

        Debug.Log(testCubeXPos);
    }

        /// <summary>
        /// 
        /// </summary>
        public static string ConvertTo(string text, TransliteType type, DirectionType direct)
        {
            string output = text;

            Dictionary<string, string> tdictF = SetDictionary(type);

            foreach (KeyValuePair<string, string> key in tdictF)
            {
                if(direct == DirectionType.OnKaz)
                {
                    output = output.Replace(key.Key, key.Value);
                }
                else if(direct == DirectionType.OutKaz)
                {
                    output = output.Replace(key.Value, key.Key);
                }
            }

            Dispose();

            return output;
        }

 protected override bool OnFocused(DirectionType direction)
 {
     return true;
 }