~grubng-dev/grubng/tools-urlsdb

// RangeCoderBitTree.cs
//  
//  Copyright (C) 2009 Bartek Jasicki based on LZMA SDK
// 
//  This file is part of Grubng
// 
//  Grubng is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
// 
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
// 
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
// 

using System;

namespace Grubng
{
	struct BitTreeEncoder : IEquatable<BitTreeEncoder>
	{
		BitEncoder[] Models;
		int NumBitLevels;

		public BitTreeEncoder(int numBitLevels)
		{
			NumBitLevels = numBitLevels;
			Models = new BitEncoder[1 << numBitLevels];
		}

		public void Init()
		{
			for (uint i = 1; i < (1 << NumBitLevels); i++)
				Models[i].Init();
		}

		/// <summary>
		/// Merge functions Encode() and ReverseEncode()
		/// </summary>
		/// <param name="rangeEncoder">
		/// A <see cref="Encoder"/>
		/// </param>
		/// <param name="symbol">
		/// A <see cref="System.uint"/>
		/// </param>
		/// <param name="reverse">
		/// A <see cref="System.Boolean"/> if true use ReverseEncode()
		/// </param>
		public void Encode(RangeEncoder rangeEncoder, uint symbol, bool reverse)
		{
			uint m = 1;
			uint bit;
			if (!reverse)
			{
				for (int bitIndex = this.NumBitLevels; bitIndex > 0; )
				{
					bitIndex--;
					bit = (symbol >> bitIndex) & 1;
					this.Models[m].Encode(rangeEncoder, bit);
					m = (m << 1) | bit;
				}
			}
			else
			{
				for (uint i = 0; i < this.NumBitLevels; i++)
				{
					bit = symbol & 1;
					this.Models[m].Encode(rangeEncoder, bit);
					m = (m << 1) | bit;
					symbol >>= 1;
				}
			}
		}

		/// <summary>
		///  Merge GetPrice() and ReverseGetPrice() functions
		/// </summary>
		/// <param name="symbol">
		/// A <see cref="System.uint"/>
		/// </param>
		/// <param name="reverse">
		/// A <see cref="System.Boolean"/> if true, use ReverseGetPrice() function
		/// </param>
		/// <returns>
		/// A <see cref="System.uint"/>
		/// </returns>
		public uint GetPrice(uint symbol, bool reverse)
		{
			uint price = 0;
			uint m = 1;
			uint bit;
			if (!reverse)
			{
				for (int bitIndex = this.NumBitLevels; bitIndex > 0; )
				{
					bitIndex--;
					bit = (symbol >> bitIndex) & 1;
					price += this.Models[m].GetPrice(bit);
					m = (m << 1) + bit;
				}
			}
			else
			{
				for (int i = this.NumBitLevels; i > 0; i--)
				{
					bit = symbol & 1;
					symbol >>= 1;
					price += this.Models[m].GetPrice(bit);
					m = (m << 1) | bit;
				}
			}
			return price;
		}

		public static uint ReverseGetPrice(BitEncoder[] Models, uint startIndex,
			int NumBitLevels, uint symbol)
		{
			uint price = 0;
			uint m = 1;
			uint bit;
			for (int i = NumBitLevels; i > 0; i--)
			{
				bit = symbol & 1;
				symbol >>= 1;
				price += Models[startIndex + m].GetPrice(bit);
				m = (m << 1) | bit;
			}
			return price;
		}

		public static void ReverseEncode(BitEncoder[] Models, uint startIndex,
			RangeEncoder rangeEncoder, int NumBitLevels, uint symbol)
		{
			uint m = 1;
			uint bit;
			for (int i = 0; i < NumBitLevels; i++)
			{
				bit = symbol & 1;
				Models[startIndex + m].Encode(rangeEncoder, bit);
				m = (m << 1) | bit;
				symbol >>= 1;
			}
		}
		
		/// <summary>
		/// Function override standard Object.Equals(object) function
		/// </summary>
		/// <param name="obj">
		/// A <see cref="System.Object"/> Object to compare
		/// </param>
		/// <returns>
		/// A <see cref="System.Boolean"/> True if both objects are that same, otherwise false
		/// </returns>
		public override bool Equals(object obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (GetType() != obj.GetType()) 
			{
				return false;
			}    
			BitTreeEncoder btencoder = (BitTreeEncoder)obj;                    
			return this == btencoder;
		}
        
		/// <summary>
		/// Function overload function BitTreeEncoder.Equals(object)
		/// </summary>
		/// <param name="right">
		/// A <see cref="BitTreeEncoder"/> value to compare
		/// </param>
		/// <returns>
		/// A <see cref="System.Boolean"/> True if both objects are that same, otherwise false
		/// </returns>
		public bool Equals(BitTreeEncoder right)
		{                    
			return this == right;
		}
		
		/// <summary>
		/// Function override operator ==
		/// </summary>
		/// <param name="left">
		/// A <see cref="BitTreeEncoder"/> left value to compare
		/// </param>
		/// <param name="right">
		/// A <see cref="BitTreeEncoder"/> right value to compare
		/// </param>
		/// <returns>
		/// A <see cref="System.Boolean"/> True if both object are that same, otherwise false
		/// </returns>
		public static bool operator == (BitTreeEncoder left, BitTreeEncoder right)
		{
			return left.Equals(right);
		}
		
		/// <summary>
		/// Function override operator !=
		/// </summary>
		/// <param name="left">
		/// A <see cref="BitTreeEncoder"/> left value to compare
		/// </param>
		/// <param name="right">
		/// A <see cref="BitTreeEncoder"/> right value to compare
		/// </param>
		/// <returns>
		/// A <see cref="System.Boolean"/> True if both object different, otherwise false
		/// </returns>
		public static bool operator != (BitTreeEncoder left, BitTreeEncoder right)
		{
			return !left.Equals(right);
		}
		
		/// <summary>
		/// Function override function Object.GetHashCode();
		/// </summary>
		/// <returns>
		/// A <see cref="System.Int32"/> hash code for current instance
		/// </returns>
		public override int GetHashCode()
		{
			int hash; 
			unchecked
			{
				hash = NumBitLevels.GetHashCode();
			}       
			return hash;
		}
	}
}