protected Boolean probeXP(Depth wDepth, Eval mAlpha, Eval mBeta, Move moveExcluded, List <GoodMove> goodMoves,
out Move moveFound, out Eval mValue, out EvalType etFound)
{
var qDynamic = DynamicHash(moveExcluded);
#if XPHash128
#if XPMoveTypes
var match = new Transposition(qDynamic, HashPawn, MoveTypeOrdering, State.MovePly, wDepth);
#else
var match = new Transposition(qDynamic, HashPawn, State.MovePly, wDepth);
#endif
#else // XPHash128
#if XPMoveTypes
var match = new Transposition(qDynamic, MoveTypeOrdering, State.MovePly, wDepth);
#else
var match = new Transposition(qDynamic, State.MovePly, wDepth);
#endif
#endif
var bValid = State.XPTank.LoadFirst(ref match);
#if XPMoveTypes
if (bValid)
{
MoveTypeOrdering = match.MoveTypeOrdering;
}
#endif
moveFound = adjustEmptyMove(match.BestMove); //[out]3
etFound = match.Type; //[out]2
var mValueFound = match.Value;
traceVal("probeXP", mValueFound, etFound); //[Conditional]
mValue = addMove(moveFound, goodMoves, wDepth, mValueFound, mAlpha, mBeta, etFound); //[out]1
var bValueDefined = EvalUndefined < mValue;
return(bValid && bValueDefined);
}
private void Switch(Transposition trans)
{
int tmp = permutation[trans.i1];
permutation[trans.i1] = permutation[trans.i2];
permutation[trans.i2] = tmp;
}
public int GetCountRod(Transposition plane)
{
if (plane.Count != Blanks.Count)
{
throw new ArgumentOutOfRangeException("Incorrect transposition");
}
var bars = new List <RodDto>();
foreach (var number in plane)
{
var len = Blanks[number - 1];
var added = false;
foreach (var bar in bars)
{
if (bar.Length >= len.Length)
{
bar.Length -= len.Length;
added = true;
break;
}
}
if (added == false)
{
bars.Add(new RodDto {
Length = Rod.Length - len.Length
});
}
}
return(bars.Count);
}
public ActionResult <ReviewProcessApiO> Patch([FromBody] ReviewProcessApiO model)
{
if (this.AppConfigurationService.IsDevelopment == true)
{
System.Threading.Thread.Sleep(7000); // sleep for 7 seconds just to see the animations working.
}
try
{
if (ModelState.IsValid == false)
{
ModelState.TryAddModelError(string.Empty, "The data is not valid");
return(BadRequest(ModelState));
}
else
{
using (Transposition transposition = new Transposition())
{
ReviewProcessViewModel result = transposition.Transpose <ReviewProcessApiO, ReviewProcessViewModel>(model, new ReviewProcessViewModel());
this.ReviewService.SaveReview(result, User.Identity.Name);
return(model); // return the same object as was sent with status code 200 ok.
}
}
}
catch (Exception e)
{
// return internal server error.
return(StatusCode(500, e));
}
}
public async Task <ActionResult> Create(DayRecordViewModel record, HttpPostedFileBase uploadImage)
{
if (ModelState.IsValid)
{
string currentUserId = User.Identity.GetUserId();
ApplicationUser currentUser = db.Users.FirstOrDefault(x => x.Id == currentUserId);
DayBookModel dayBook = new DayBookModel();
dayBook.ApplicationUser = currentUser;
dayBook.ApplicationUserId = User.Identity.GetUserId();
dayBook.CreationTime = DateTime.Now;
dayBook.DayRecord = Transposition.GetEncryptedString(record.DayRecord);
db.DayBooks.Add(dayBook);
ImageModel imageModel = new ImageModel();
byte[] imageData;
using (var binaryReader = new BinaryReader(uploadImage.InputStream))
{
imageData = binaryReader.ReadBytes(uploadImage.ContentLength);
}
imageModel.ImageTitle = record.ImageTitle;
imageModel.ImageByte = imageData;
imageModel.DayBookModel = dayBook;
db.ImageModels.Add(imageModel);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(record));
}
public void OrderMoves(List <Move> moves, Gameboard state, Move bestMove = null)
{
// Assign values to moves, if possible
for (int i = 0; i < moves.Count; i++)
{
moves[i].Value = 0;
// Check for best move from last iteration
if (moves[i] == bestMove)
{
// Best move is slightly better rated than other moves
moves[i].Value = 1;
}
Gameboard newState = (Gameboard)state.Clone();
GameLogic newLogic = new GameLogic(newState);
newLogic.ApplyMove(moves[i]);
Int64 zHash = newState.GetZobristHash();
if (transpositionTable.ContainsKey(zHash))
{
Transposition transposition = transpositionTable[zHash];
if (transposition.Lowerbound == transposition.Upperbound)
{
moves[i].Value += transposition.Lowerbound;
}
}
}
moves.Sort(MoveComparison);
}
/// <summary>
/// Decode day record row from database to initial view
/// </summary>
/// <param name="dayBooks"></param>
/// <returns></returns>
private List <DayBookModel> DectyptRecords(List <DayBookModel> dayBooks)
{
for (int i = 0; i < dayBooks.Count; i++)
{
dayBooks[i].DayRecord = Transposition.GetDecryptedString(dayBooks[i].DayRecord);
}
return(dayBooks);
}
public void AddKnowledge(Transposition newKnowledge, bool changer = false)
{
if (changer)
{
changed = true;
}
knowledge.Add(newKnowledge);
}
private string DoTransposition(Transposition transpo, string transposed)
{
string first = transpo.First;
string second = transpo.Second;
InsertSpace(first);
InsertSpace(second);
return(transposed.Replace(first, second));
}
private string GetActualKnowledge(string requestedKnowledge)
{
Transposition knowledge = database.RetrieveKnowledge(requestedKnowledge);
if (knowledge != null)
{
return(knowledge.Second);
}
return("I DON'T KNOW WHAT YOU ARE TALKING ABOUT.");
}
public ProductApiO GetProduct(int productId)
{
Product product = this.ProductRepository.Fetch(productId);
ProductApiO result = new ProductApiO();
using (Transposition transposition = new Transposition())
{
result = transposition.Transpose <ProductApiO>(product, result);
}
return(result);
}
public CategoryRowApiO GetCategory(int categoryId)
{
Category category = this.CategoryRepository.Fetch(categoryId);
CategoryRowApiO result = new CategoryRowApiO();
using (Transposition tranposition = new Transposition())
{
result = tranposition.Transpose <CategoryRowApiO>(category, result);
}
return(result);
}
public async Task <ActionResult> Edit([Bind(Include = "DayBoolKey,DayRecord,CreationTime,ApplicationUserId")] DayBookModel dayBook)
{
if (ModelState.IsValid)
{
dayBook.DayRecord = Transposition.GetEncryptedString(dayBook.DayRecord);
db.Entry(dayBook).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(dayBook));
}
public void TestCanCreateTransposition()
{
List <Key> keys = new List <Key>();
keys.Add(Key.FromRoot("A"));
keys.Add(Key.FromRoot("B"));
Song originalSong = new Song(keys);
Transposition actual = new Transposition(originalSong, 2);
Assert.Equal("A", actual.OriginalSong.Keys[0].Root);
Assert.Equal("G", actual.NewSong.Keys[0].Root);
}
private void AddNewKnowledge()
{
io.WriteLine("Ok. So what is the knowledge title ?");
io.Write("> ");
string title = io.ReadLine();
io.WriteLine("And with what data does it match ?");
io.Write("> ");
string data = io.ReadLine();
Transposition knowledge = new Transposition("knowledge", title, data);
database.AddKnowledge(knowledge, true);
}
public List <ProductApiO> GetAllProducts()
{
List <Product> products = this.ProductRepository.FetchAll.OrderBy(o => o.ProductName).ToList();
List <ProductApiO> result = new List <ProductApiO>();
using (Transposition transposition = new Transposition())
{
foreach (Product item in products)
{
result.Add(transposition.Transpose <ProductApiO>(item, new ProductApiO()));
}
}
return(result);
}
// GET: DayBooks/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DayBookModel dayBook = await db.DayBooks.FindAsync(id);
dayBook.DayRecord = Transposition.GetDecryptedString(dayBook.DayRecord);
if (dayBook == null)
{
return(HttpNotFound());
}
return(View(dayBook));
}
/// <summary>
/// Fetches all the items
/// </summary>
/// <returns></returns>
public List <TApiRowModel> FetchAll(Func <TDbModel, TFetchSortFieldType> sortOrder)
{
List <TDbModel> table = this.Repository.FetchAll.OrderBy(sortOrder).ToList();
List <TApiRowModel> result = new List <TApiRowModel>();
using (Transposition transposition = new Transposition())
{
foreach (TDbModel row in table)
{
result.Add(transposition.Transpose <TApiRowModel>(row, Activator.CreateInstance <TApiRowModel>()));
}
}
return(result);
}
public List <CategoryRowApiO> GetAllCategories()
{
List <Category> categories = this.CategoryRepository.FetchAll.OrderBy(c => c.CategoryName).ToList();
List <CategoryRowApiO> result = new List <CategoryRowApiO>();
using (Transposition transposition = new Transposition())
{
foreach (Category item in categories)
{
result.Add(transposition.Transpose <CategoryRowApiO>(item, new CategoryRowApiO()));
}
}
return(result);
}
public List <ProductApiO> GetProductsPaged(int itemsPerPage, int page)
{
page -= 1;
List <Product> pagedProducts = this.ProductRepository.FetchAll.OrderBy(p => p.ProductName).Skip(itemsPerPage * page).Take(itemsPerPage).ToList();
List <ProductApiO> result = new List <ProductApiO>();
using (Transposition transposition = new Transposition())
{
foreach (Product item in pagedProducts)
{
result.Add(transposition.Transpose <ProductApiO>(item, new ProductApiO()));
}
}
return(result);
}
public List <CategoryRowApiO> GetCategoriesPaged(int itemsPerPage, int page)
{
page -= 1;
List <Category> pagedCategories = this.CategoryRepository.FetchAll.OrderBy(c => c.CategoryName).Skip(itemsPerPage * page).Take(itemsPerPage).ToList();
List <CategoryRowApiO> result = new List <CategoryRowApiO>();
using (Transposition transposition = new Transposition())
{
foreach (Category item in pagedCategories)
{
result.Add(transposition.Transpose <CategoryRowApiO>(item, new CategoryRowApiO()));
}
}
return(result);
}
protected Eval storeXP(Depth wDepth, Eval mValue, EvalType et,
Move moveBest = Move.Undefined,
Move moveExcluded = Move.Undefined) // 10 MHz
{
Trace.Assert(EvalUndefined < mValue, "storeXP(EvalUndefined)");
traceVal("storeXP", mValue, et); //[Conditional]
State.IncEvalType(et);
var qDynamic = DynamicHash(moveExcluded);
var mAdjusted = creditMate(mValue, SearchPly);
if (IsFinal())
{
Trace.Assert(!isDefined(moveBest), "moveBest defined in a Final position.");
moveBest = Move.EmptyMove;
}
#if DebugMoveColor
if (isDefinite(moveBest))
{
var bWTM = WTM();
var bWhiteMove = (moveBest & Move.WTM) != 0;
if (bWTM != bWhiteMove)
{
Debug.Assert(bWTM == bWhiteMove, "WTM != WhiteMove [storeXP]");
DisplayCurrent("storeXP()");
}
}
#endif
#if XPHash128
#if XPMoveTypes
var store = new Transposition(qDynamic, HashPawn, MoveTypeOrdering, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#else
var store = new Transposition(qDynamic, HashPawn, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#endif
#else // XPHash128
#if XPMoveTypes
var store = new Transposition(qDynamic, MoveTypeOrdering, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#else
var store = new Transposition(qDynamic, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#endif
#endif
State.XPTank.Save(store);
return(mValue);
}
/// <summary>
/// Adds a new record
/// </summary>
/// <param name="apiModel"></param>
/// <returns>The key for the new record.</returns>
public CategoryRowApiO Create(CategoryRowApiO apiModel)
{
CategoryRowApiO result = default(CategoryRowApiO);
if (apiModel == null)
{
throw new ArgumentNullException("The input parameter cannot be null");
}
else
{
if (ModelState.IsValid == false)
{
string modelType = apiModel.GetType().ToString();
ModelState.AddModelError(string.Empty, string.Format("Validation Failed, the {0} contains invalid data.", modelType));
throw new ModelStateException(string.Format("The {0} is not valid", modelType), ModelState);
}
else
{
// check the item does not already exist
Category dbModel = this.CategoryRepository.FetchAll.Where(cat => cat.CategoryName == apiModel.CategoryName).FirstOrDefault();
if (dbModel != null)
{
// the item already exists
throw new RecordFoundException(string.Format("A record for '{0}' already exists!", apiModel.CategoryId.ToString()));
}
else
{
dbModel = new Category();
// map the item and add it
using (Transposition transposition = new Transposition())
{
dbModel = transposition.Transpose <Category>(apiModel, dbModel);
this.CategoryRepository.Create(dbModel);
result = transposition.Transpose <CategoryRowApiO>(dbModel, apiModel);
}
}
}
}
return(result);
}
/// <summary>
/// Adds a new record
/// </summary>
/// <param name="apiRowModel"></param>
/// <param name="existingRecordSelector">Selector for existing record</param>
/// <returns>The key for the new record.</returns>
/// <remarks>The existing record selector must select the record without using the key (it will be 0 in a new record).</remarks>
public TApiRowModel Create(TApiRowModel apiRowModel, Func <TDbModel, bool> existingRecordSelector)
{
TApiRowModel result = default(TApiRowModel);
if (apiRowModel == null)
{
throw new ArgumentNullException("The input parameter cannot be null");
}
else
{
if (ModelState.IsValid == false)
{
string modelType = apiRowModel.GetType().ToString();
ModelState.AddModelError(string.Empty, string.Format("Validation Failed, the {0} contains invalid data.", modelType));
throw new ModelStateException(string.Format("The {0} is not valid", modelType), ModelState);
}
else
{
// check the item does not already exist
TDbModel dbModel = this.Repository.FetchAll.Where(existingRecordSelector).FirstOrDefault();
if (dbModel != null)
{
// the item already exists
throw new RecordFoundException("This record already exists!");
}
else
{
dbModel = Activator.CreateInstance <TDbModel>();
// map the item and add it
using (Transposition transposition = new Transposition())
{
dbModel = transposition.Transpose <TDbModel>(apiRowModel, dbModel);
this.Repository.Create(dbModel);
result = transposition.Transpose <TApiRowModel>(dbModel, apiRowModel);
}
}
}
}
return(result);
}
public Transposition GetTransposition(InputData data)
{
var bestResult = int.MaxValue;
var bestTrasnposition = new Transposition(data.Blanks.Count);
for (var i = 0; i < iterationCount; i++)
{
var transposition = GetIterateTransposition2(data);
var result = data.GetCountRod(transposition);
if (result < bestResult)
{
bestResult = result;
bestTrasnposition = transposition;
}
}
return(bestTrasnposition);
}
public List <ProductRowApiO> GetCategoryProducts(int categoryId)
{
Category category = this.CategoryRepository.Fetch(categoryId);
List <ProductRowApiO> result = new List <ProductRowApiO>();
if (category != null)
{
using (Transposition transposition = new Transposition())
{
foreach (Product item in category.Products)
{
result.Add(transposition.Transpose <ProductRowApiO>(item, new ProductRowApiO()));
}
}
}
return(result);
}
/// <summary>
/// Update a record in the database.
/// </summary>
/// <param name="apiRowModel"></param>
/// <param name="existingRecordSelector">Selector for existing records</param>
/// <returns></returns>
public TApiRowModel Update(TApiRowModel apiRowModel, Func <TDbModel, bool> existingRecordSelector)
{
TApiRowModel result = default(TApiRowModel);
if (apiRowModel == null)
{
throw new ArgumentNullException("The input parameter cannot be null");
}
else
{
if (ModelState.IsValid == false)
{
string modelType = apiRowModel.GetType().ToString();
ModelState.AddModelError(string.Empty, string.Format("Validation Failed, the {0} contains invalid data.", modelType));
throw new ModelStateException(string.Format("The {0} is not valid", modelType), ModelState);
}
else
{
// find the item
TDbModel dbModel = this.Repository.FetchAll.Where(existingRecordSelector).FirstOrDefault();
if (dbModel == null)
{
// item was not found!
throw new RecordNotFoundException("Could not find a item to update.");
}
else
{
// map the apiO to the db model.
using (Transposition transposition = new Transposition())
{
dbModel = transposition.Transpose <TDbModel>(apiRowModel, dbModel);
// update the item
this.Repository.Update(dbModel);
result = transposition.Transpose <TApiRowModel>(dbModel, apiRowModel);
}
}
}
}
return(result);
}
public CategoryRowApiO Update(CategoryRowApiO apiModel)
{
CategoryRowApiO result = default(CategoryRowApiO);
if (apiModel == null)
{
throw new ArgumentNullException("The input parameter cannot be null");
}
else
{
if (ModelState.IsValid == false)
{
string modelType = apiModel.GetType().ToString();
ModelState.AddModelError(string.Empty, string.Format("Validation Failed, the {0} contains invalid data.", modelType));
throw new ModelStateException(string.Format("The {0} is not valid", modelType), ModelState);
}
else
{
// find the item
Category dbModel = this.CategoryRepository.Fetch(apiModel.CategoryId);
if (dbModel == null)
{
// item was not found!
throw new RecordNotFoundException("Could not find a item with id '{0}'", apiModel.CategoryId.ToString());
}
else
{
// map the apiO to the db model.
using (Transposition transposition = new Transposition())
{
dbModel = transposition.Transpose <Category>(apiModel, dbModel);
// update the item
this.CategoryRepository.Update(dbModel);
result = transposition.Transpose <CategoryRowApiO>(dbModel, apiModel);
}
}
}
}
return(result);
}
/// <summary>
/// Fetches 1 item
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public TApiRowModel Fetch(TDbModelKey key)
{
TDbModel row = this.Repository.Fetch(key);
if (row == null)
{
throw new RecordNotFoundException("Could not find a item with id '{0}'", key.ToString());
}
else
{
TApiRowModel result = Activator.CreateInstance <TApiRowModel>();
using (Transposition tranposition = new Transposition())
{
result = tranposition.Transpose <TApiRowModel>(row, result);
}
return(result);
}
}
/// <summary>
/// Fetches 1 item without using its key.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public TApiRowModel Fetch(TApiRowModel apiRowModel, Func <TDbModel, bool> fetchSelector)
{
TDbModel row = this.Repository.FetchAll.Where(fetchSelector).FirstOrDefault();
if (row == null)
{
throw new RecordNotFoundException("Could not find a matching item.");
}
else
{
TApiRowModel result = Activator.CreateInstance <TApiRowModel>();
using (Transposition transposition = new Transposition())
{
result = transposition.Transpose <TApiRowModel>(row, result);
}
return(result);
}
}
public void Run() {
Console.WriteLine("Available algorithms for encoding/decoding:");
Console.WriteLine("1 - Vigenere Substitution.");
Console.WriteLine("2 - Transposition Letter by Letter.");
Console.WriteLine("3 - Phone Code.");
Console.WriteLine("4 - Binary Code.");
Console.WriteLine("5 - Keyword.");
Console.Write("\nType the algoritm #: ");
algoritm = Convert.ToInt32(Console.ReadLine());
Console.Write("Type the phrase: ");
input_phrase = Console.ReadLine();
switch (algoritm) {
case 1:
Console.WriteLine("\nVigenere Substitution.");
Console.Write("Type the value: ");
value = Convert.ToInt32(Console.ReadLine());
if (value > 10 && value < 99) {
Console.WriteLine("1 - Encode.");
Console.WriteLine("2 - Decode.");
Console.Write("Procedure #: ");
procedure = Convert.ToInt32(Console.ReadLine());
Vigenere_Substitution vs = new Vigenere_Substitution(input_phrase, value.ToString());
switch (procedure) {
case 1:
vs.Encode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + vs.GetInput_Phrase());
Console.WriteLine("Encoded phrase: " + vs.GetOutput_Phrase());
break;
case 2:
vs.Decode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + vs.GetInput_Phrase());
Console.WriteLine("Decoded phrase: " + vs.GetOutput_Phrase());
break;
default:
Console.WriteLine("\nNo option.");
break;
}
Console.Write("\nExport results? (Y/N) ");
export = Console.ReadLine();
switch (export[0]) {
case 'Y':
Console.Write("Type a name for the output file: ");
file_name = Console.ReadLine();
vs.Export(file_name);
break;
case 'N':
break;
default:
Console.WriteLine("No option.");
break;
}
}
else {
Console.WriteLine("Invalid value.");
}
break;
case 2:
Console.WriteLine("\nTransposition Letter by Letter.");
Console.WriteLine("1 - Encode phrase.");
Console.WriteLine("2 - Decode phrase.");
Console.Write("Procedure #: ");
procedure = Convert.ToInt32(Console.ReadLine());
Transposition t = new Transposition(input_phrase);
switch (procedure) {
case 1:
t.Encode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + t.GetInput_Phrase());
Console.WriteLine("Encoded phrase: " + t.GetOutput_Phrase());
break;
case 2:
t.Decode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + t.GetInput_Phrase());
Console.WriteLine("Decoded phrase: " + t.GetOutput_Phrase());
break;
default:
Console.WriteLine("\nNo option.");
break;
}
Console.Write("\nExport results? (Y/N) ");
export = Console.ReadLine();
switch (export[0]) {
case 'Y':
Console.Write("Type a name for the output file: ");
file_name = Console.ReadLine();
t.Export(file_name);
break;
case 'N':
break;
default:
Console.WriteLine("No option.");
break;
}
break;
case 3:
Console.WriteLine("\nPhone Code.");
Console.WriteLine("1 - Encode phrase.");
Console.WriteLine("2 - Decode phrase.");
Console.Write("Procedure #: ");
procedure = Convert.ToInt32(Console.ReadLine());
Phone_Code pc = new Phone_Code(input_phrase);
pc.SetPhone_Numbers();
switch (procedure) {
case 1:
pc.Encode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + pc.GetInput_Phrase());
Console.WriteLine("Encoded phrase: " + pc.GetOutput_Phrase());
break;
case 2:
pc.Decode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + pc.GetInput_Phrase());
Console.WriteLine("Decoded phrase: " + pc.GetOutput_Phrase());
break;
default:
Console.WriteLine("\nNo option.");
break;
}
Console.Write("\nExport results? (Y/N) ");
export = Console.ReadLine();
switch (export[0]) {
case 'Y':
Console.Write("Type a name for the output file: ");
file_name = Console.ReadLine();
pc.Export(file_name);
break;
case 'N':
break;
default:
Console.WriteLine("No option.");
break;
}
break;
case 4:
Console.WriteLine("\nBinary Code.");
Console.WriteLine("1 - Encode phrase.");
Console.WriteLine("2 - Decode phrase.");
Console.Write("Procedure #: ");
procedure = Convert.ToInt32(Console.ReadLine());
Binary_Code bc = new Binary_Code(input_phrase);
bc.SetBinary_Equivalents();
switch (procedure) {
case 1:
bc.Encode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + bc.GetInput_Phrase());
Console.WriteLine("Encoded phrase: " + bc.GetOutput_Phrase());
break;
case 2:
bc.Decode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + bc.GetInput_Phrase());
Console.WriteLine("Decoded phrase: " + bc.GetOutput_Phrase());
break;
default:
Console.WriteLine("\nNo option.");
break;
}
Console.Write("\nExport results? (Y/N) ");
export = Console.ReadLine();
switch (export[0]) {
case 'Y':
Console.Write("Type a name for the output file: ");
file_name = Console.ReadLine();
bc.Export(file_name);
break;
case 'N':
break;
default:
Console.WriteLine("No option.");
break;
}
break;
case 5:
Console.WriteLine("\nKeyword.");
Console.Write("Type the keyword: ");
keyword = Console.ReadLine();
Console.WriteLine("1 - Encode phrase.");
Console.WriteLine("2 - Decode phrase.");
Console.Write("Procedure #: ");
procedure = Convert.ToInt32(Console.ReadLine());
Keyword kw = new Keyword(input_phrase, keyword);
switch (procedure) {
case 1:
kw.Encode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + kw.GetInput_Phrase());
Console.WriteLine("Encoded phrase: " + kw.GetOutput_Phrase());
break;
case 2:
kw.Decode();
Console.WriteLine("\n-- Successful encoding procedure --");
Console.WriteLine("Original phrase: " + kw.GetInput_Phrase());
Console.WriteLine("Decoded phrase: " + kw.GetOutput_Phrase());
break;
default:
Console.WriteLine("\nNo option.");
break;
}
Console.Write("\nExport results? (Y/N) ");
export = Console.ReadLine().ToLower();
switch (export[0]) {
case 'y':
Console.Write("Type a name for the output file: ");
file_name = Console.ReadLine();
kw.Export(file_name);
break;
case 'n':
break;
default:
Console.WriteLine("No option.");
break;
}
break;
default:
Console.WriteLine("\nNo option.");
break;
}
}