protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);
            _appTask = AppTask.GetTaskInOnCreate(bundle, Intent);
            SetContentView(Resource.Layout.search);
            SearchParameters sp = new SearchParameters();
            PopulateCheckBox(Resource.Id.cbSearchInTitle, sp.SearchInTitles);
            PopulateCheckBox(Resource.Id.cbSearchInUsername, sp.SearchInUserNames);
            PopulateCheckBox(Resource.Id.cbSearchInNotes, sp.SearchInNotes);
            PopulateCheckBox(Resource.Id.cbSearchInPassword, sp.SearchInPasswords);
            PopulateCheckBox(Resource.Id.cbSearchInTags, sp.SearchInTags);
            PopulateCheckBox(Resource.Id.cbSearchInGroupName, sp.SearchInGroupNames);
            PopulateCheckBox(Resource.Id.cbSearchInUrl, sp.SearchInUrls);
            PopulateCheckBox(Resource.Id.cbSearchInOtherStrings, sp.SearchInOther);
            PopulateCheckBox(Resource.Id.cbRegEx, sp.RegularExpression);

            StringComparison sc = sp.ComparisonMode;
            bool caseSensitive = ((sc != StringComparison.CurrentCultureIgnoreCase) &&
                                         (sc != StringComparison.InvariantCultureIgnoreCase) &&
                                         (sc != StringComparison.OrdinalIgnoreCase));
            PopulateCheckBox(Resource.Id.cbCaseSensitive, caseSensitive);
            PopulateCheckBox(Resource.Id.cbExcludeExpiredEntries, sp.ExcludeExpired);

            ImageButton btnSearch = (ImageButton)FindViewById(Resource.Id.search_button);

            btnSearch.Click += (sender, e) => PerformSearch();

            FindViewById<EditText>(Resource.Id.searchEditText).EditorAction += (sender, e) =>
            {
                if (e.ActionId == Android.Views.InputMethods.ImeAction.Search) {
                    PerformSearch();
                }
            };
        }

 public Search(SearchParameters p, Player searchingPlayer, SearchResults searchResults, Game game)
 {
     _p = p;
       _searchResults = searchResults;
       _game = game;
       _root = new InnerResult(_game.CalculateHash(), searchingPlayer.IsMax, 0);
 }

        internal static string GetTransformation(SearchParameters spIn)
        {
            if(spIn == null) { Debug.Assert(false); return string.Empty; }

            if(spIn.DataTransformationFn == null) return string.Empty;
            return StrTrfDeref;
        }

 public void Constructor_Full_NullDocumentTypeTags()
 {
     SearchParameters par = new SearchParameters("query", null, SearchOptions.AllWords);
     Assert.AreEqual("query", par.Query, "Wrong query");
     Assert.IsNull(par.DocumentTypeTags, "DocumentTypeTags should be null");
     Assert.AreEqual(SearchOptions.AllWords, par.Options);
 }

		/// <summary>
		/// Binds the model to a value by using the specified controller context and binding context.
		/// </summary>
		/// <param name="controllerContext">The controller context.</param>
		/// <param name="bindingContext">The binding context.</param>
		/// <returns>The bound value.</returns>
        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
		  
		    var parameters = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            var sp = parameters != null ? parameters.RawValue as SearchParameters : null;
		    if (sp == null)
		    {
            var qs = GetParams(controllerContext);
            var qsDict = NvToDict(qs);
            var facets = qsDict.Where(k => FacetRegex.IsMatch(k.Key)).Select(k => k.WithKey(FacetRegex.Replace(k.Key, ""))).ToDictionary(x=>x.Key, y=>y.Value.Split(','));

		    sp = new SearchParameters
            {
                FreeSearch = qs["q"].EmptyToNull(),
                PageIndex = qs["p"].TryParse(1),
                PageSize = qs["pageSize"].TryParse(0),
                Sort = qs["sort"].EmptyToNull(),
		        SortOrder = qs["sortorder"].EmptyToNull(),
                Facets = facets
            };
		        if (!string.IsNullOrEmpty(sp.FreeSearch))
		        {
		            sp.FreeSearch = sp.FreeSearch.EscapeSearchTerm();
		        }
		    }
            return sp;
        }

 /// <summary>
 /// Creates a clear map with a start and end point and sets up the search parameters
 /// </summary>
 private void InitializeMap(int[,] iMap, Point S, Point F)
 {
     this.map = IntToBool(iMap);
     //var tmp = BoolToString(map);
     //var tmp1 = ParseIntArrayToString(iMap);
     this.sp = new SearchParameters(S, F, map);
 }

 // Loads UI elements and an initial webmap
 private async void LoadWebMap_Loaded(object sender, RoutedEventArgs e)
 {
     _portal = await ArcGISPortal.CreateAsync();
     var searchParams = new SearchParameters("type: \"web map\" NOT \"web mapping application\"");
     var result = await _portal.ArcGISPortalInfo.SearchHomePageFeaturedContentAsync(searchParams);
     comboWebMap.ItemsSource = result.Results;
 }

    public SearchRunner(SearchParameters searchParameters, Game game)
    {
      _game = game;
      _searchParameters = searchParameters;

      CurrentDepth = _searchParameters.SearchDepth;
      CurrentTargetCount = _searchParameters.TargetCount;
    }

 /// <summary>
 /// Create a new instance of PathFinder
 /// </summary>
 /// <param name="searchParameters"></param>
 public PathFinder(SearchParameters searchParameters)
 {
     this.searchParameters = searchParameters;
     InitializeNodes(searchParameters.Map);
     this.startNode = this.nodes[searchParameters.StartLocation.X, searchParameters.StartLocation.Y];
     this.startNode.State = NodeState.Open;
     this.endNode = this.nodes[searchParameters.EndLocation.X, searchParameters.EndLocation.Y];
 }

 public void RegisterSearchChannel(SearchContext searchContext)
 {
     this._searchService.GetSearchParameters(CLAIMS_SEARCH_SP_NAME, parameters =>
     {
         this._searchParameters = parameters;
         searchContext.RegisterSearchChannel(this.GetChannel(this._searchTypeName));
     });
 }

        public SearchResults Search(SearchParameters parameters)
        {
            if (string.IsNullOrEmpty(parameters.Query) && string.IsNullOrEmpty(parameters.Title) && string.IsNullOrEmpty(parameters.Skills))
            {
                throw new ArgumentException("At least one of the Query, Title, or Skills parameters must be specified.");
            }

            return restTemplate.GetForObject<SearchResults>(searchBaseUri + parameters.ToString());
        }

 public void Test_Selected_Filters_To_Search_Parameter()
 {
     var query = Conditions.From("MAYY380WWPGYY1", urlOfuscator);
     var selectedFiltersContext = new QueryUrlParser(facetConfiguration.FacetHierarchy, urlOfuscator).Parse(query).GetSelectedFilters();
     var searchParameter = new SearchParameters<Publication>(string.Empty, selectedFiltersContext,
                                                             facetConfiguration.FacetHierarchy.ByName(selectedFiltersContext.SelectedFilters.Last().Name),
                                                             facetConfiguration.FacetHierarchy.FacetsNotInBranchOf((selectedFiltersContext.SelectedFilters.Last().Name)));
     var result = indexServiceImpl.Query(searchParameter);
 }

 public void Constructor_QueryDocumentTypeTags()
 {
     SearchParameters par = new SearchParameters("query", "blah", "doc");
     Assert.AreEqual("query", par.Query, "Wrong query");
     Assert.AreEqual(2, par.DocumentTypeTags.Length, "Wrong DocumentTypeTag count");
     Assert.AreEqual("blah", par.DocumentTypeTags[0], "Wrong type tag");
     Assert.AreEqual("doc", par.DocumentTypeTags[1], "Wrong type tag");
     Assert.AreEqual(SearchOptions.AtLeastOneWord, par.Options);
 }

 public void Constructor_Full()
 {
     SearchParameters par = new SearchParameters("query", new string[] { "blah", "doc" }, SearchOptions.AllWords);
     Assert.AreEqual("query", par.Query, "Wrong query");
     Assert.AreEqual(2, par.DocumentTypeTags.Length, "Wrong DocumentTypeTag count");
     Assert.AreEqual("blah", par.DocumentTypeTags[0], "Wrong type tag");
     Assert.AreEqual("doc", par.DocumentTypeTags[1], "Wrong type tag");
     Assert.AreEqual(SearchOptions.AllWords, par.Options);
 }

        internal static void SetTransformation(SearchParameters spOut,
			string strTrf)
        {
            if(spOut == null) { Debug.Assert(false); return; }
            if(strTrf == null) { Debug.Assert(false); return; }

            if(strTrf == StrTrfDeref)
                spOut.DataTransformationFn = SprEngine.DerefFn;
            else spOut.DataTransformationFn = null;
        }

 public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) {
     var qs = controllerContext.HttpContext.Request.QueryString;
     var qsDict = NVToDict(qs);
     var sp = new SearchParameters {
         FreeSearch = StringHelper.EmptyToNull(qs["q"]),
         PageIndex = StringHelper.TryParse(qs["page"], 1),
         PageSize = StringHelper.TryParse(qs["pageSize"], DefaultPageSize),
         Sort = StringHelper.EmptyToNull(qs["sort"]),
         Facets = qsDict.Where(k => FacetRegex.IsMatch(k.Key))
             .Select(k => k.WithKey(FacetRegex.Replace(k.Key, "")))
             .ToDictionary()
     };
     return sp;
 }

 private SearchParameters MakeSearchParameters()
 {
     var p = new SearchParameters();
     p.SearchInTitles = true;
     p.RegularExpression = true;
     p.SearchInGroupNames = false;
     p.SearchInNotes = false;
     p.SearchInOther = false;
     p.SearchInPasswords = false;
     p.SearchInTags = false;
     p.SearchInUrls = true;
     p.SearchInUserNames = false;
     p.SearchInUuids = false;
     return p;
 }

   public static GameParameters Load(PlayerType player1Controller, PlayerType player2Controller,
 SavedGame savedGame, int? looser = null, int rollback = 0, SearchParameters searchParameters = null)
   {
       return new GameParameters
       {
         Player1 = savedGame.Player1,
         Player2 = savedGame.Player2,
         Player1Controller = player1Controller,
         Player2Controller = player2Controller,
         SearchParameters = searchParameters ?? SearchParameters.Default,
         SavedGame = savedGame,
         RollBack = rollback,
         Looser = looser
       };
   }

        // Loads UI elements and an initial webmap
        private async void LoadWebMap_Loaded(object sender, RoutedEventArgs e)
        {
            _portal = await ArcGISPortal.CreateAsync();

            var searchParams = new SearchParameters("type: \"web map\" NOT \"web mapping application\"");
            var result = await _portal.ArcGISPortalInfo.SearchHomePageFeaturedContentAsync(searchParams);
            comboWebMap.ItemsSource = result.Results;

            var webmap = result.Results.FirstOrDefault();
            if (webmap != null)
            {
                comboWebMap.SelectedIndex = 0;
                await LoadWebMapAsync(webmap.Id);
            }
        }

        public static Game LoadReport(string filename, int rollback = 0, SearchParameters searchParameters = null)
        {
            using (var stream = new FileStream(filename, FileMode.Open))
              {
            var saveGameFile = SavedGames.ReadFromStream(stream);

            var gameParameters = GameParameters.Load(
              player1Controller: PlayerType.Machine,
              player2Controller: PlayerType.Machine,
              savedGame: (SavedGame) saveGameFile.Data,
              rollback: rollback,
              searchParameters: searchParameters);

            return new Game(gameParameters);
              }
        }