public void setSearchStrategy(SearchStrategy newStrategy)
{
if (newStrategy != null)
{
searchStrategy = newStrategy;
}
}
public ProxyDelegate(Func <object, object>[] propertyGetters, ProxyDelegate <TSearch, TResult>[] children,
SearchStrategy <TSearch, TResult> strategy, bool isCollection) : base(children, strategy)
{
_isCollection = isCollection;
_propertyGetters = propertyGetters;
}
public static IEnumerable <Component> GetComponentsInOnlyChildren(this Transform target, Type type,
SearchStrategy strategy =
SearchStrategy.FindComponent)
{
var queue = new Queue <Transform>();
AddChildren(target);
while (queue.Any())
{
var transform = queue.Dequeue();
var components = strategy.FindComponents(transform.gameObject, type);
foreach (var component in components)
{
yield return(component);
}
AddChildren(transform);
}
void AddChildren(Transform transform)
{
for (var index = 0; index < transform.childCount; index++)
{
var child = transform.GetChild(index);
queue.Enqueue(child);
}
}
}
public void Begin(EmailSender emailSender = null)
{
var logger = LoggerFactory.GetLogger();
int interval = this.ODs.Count / this.ThreadsQuantity;
int rest = this.ODs.Count % this.ThreadsQuantity;
ThreadManager manager = new ThreadManager(this._graph, this.ThreadsQuantity, this.ODs.Count, this.Radius, this.StrategyFactory.SearchName, this.emailSender);
for (int i = 0; i < this.ThreadsQuantity; i++)
{
int begin = i * interval;
int end = interval;//i * interval + interval;
if (i + 1 == this.ThreadsQuantity)
{
end += rest;
}
List <Tuple <long, long> > portion = this.ODs.GetRange(begin, end);
Graph graphClone = this._graph.Clone();
SearchStrategy searhcStrategy = this.StrategyFactory.GetStrategy(graphClone);
var ts = new ThreadSearch(graphClone, searhcStrategy, portion, this.Radius, manager);
var thread = new Thread(new ThreadStart(ts.Search));
thread.Name = "T" + (i + 1);
logger.WriteLine(thread.Name + " ODs: " + portion.Count.ToString());
thread.Start();
}
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
TipViewModel tipViewModel = value as TipViewModel;
SearchStrategy strategy = tipViewModel.SearchStrategy;
string searchString = tipViewModel.SearchString;
return(Strategy.parseInput <string>(searchString, (first, inp) => strategy.tipMap.ContainsKey(first) && inp.Length == 1 ? first + strategy.tipMap[first] : "", AppResources.GeneralSearchTip));
}
public ThreadSearch(Graph graph, SearchStrategy strategy, List <Tuple <long, long> > ODs, double radius, ThreadManager threadManager)
{
this._graph = graph;
this.Strategy = strategy;
this.ODs = ODs;
this.Radius = radius;
this.ThreadManager = threadManager;
}
public void SetSearchStrategy(string stratString)
{
SearchStrategy strategy;
if (SearchStrategy.TryParse(stratString, true, out strategy))
{
bookservice.SetSearchStrategy(strategy);
}
}
public void SetSearchStrategy(SearchStrategy searchStrategy)
{
_searchStrategy = searchStrategy;
if (SearchStrategyChanged != null)
{
SearchStrategyChanged(this, new EventArgs <SearchStrategy> {
Data = searchStrategy
});
}
}
public void NewSeries()
{
if (SearchStrategy != null)
{
series = new LineSeries {
Title = SearchStrategy.ToString(), MarkerType = MarkerType.Circle
};
Model.Series.Add(series);
}
}
public Agent(Coordonnees c, SearchStrategy strategy)
{
_coordonnees = c;
_score = 0;
_intentions = new Intentions();
_capteurs = new Capteurs();
_effecteur = new Effecteurs();
_strategy = strategy;
_belief = new Belief();
}
public static void ApplyAttribute <TAttribute>(MonoBehaviour behaviour, SearchStrategy strategy, object obj = null)
where TAttribute : ComponentFinderAttribute
{
obj ??= behaviour;
var attributedFields = AttributeHelper.GetAttributedFields <TAttribute>(obj);
foreach (var(field, attribute) in attributedFields)
{
attribute.Apply(behaviour, obj, field, strategy);
}
}
public void Find <TElement, TResult>(
TBaseSearchInterface source,
LinkedList <TResult> resultList,
SearchStrategy <TElement, TResult> strategy,
HashSet <object> visited,
Func <TElement, TResult> action) where TElement : class, TBaseSearchInterface
{
var deleg = GetOrCreateDelegate(source, strategy);
deleg.Invoke(source, resultList, visited, action);
}
public void BasicPrettyPrint(int?OverrideRecursionLevel = null)
{
int localRecursionLevel = RecursionLevel;
if (OverrideRecursionLevel != null)
{
localRecursionLevel = (int)OverrideRecursionLevel;
}
string Tabs = string.Concat(Enumerable.Repeat("| ", localRecursionLevel));
Console.WriteLine("{0:s}├ {1:s} ({2:s}) : {3:s} ", Tabs, ModuleName, SearchStrategy.ToString(), Filepath);
}
public IEnumerable <Mural> GetAllMuralsWithSearchStrategy(string searchParameter, string search)
{
if (search == "id")
{
int searchId = Int32.Parse(searchParameter);
searchStrategy = new IDStrategy();
return(searchStrategy.SearchMuralsWithID(searchId));
}
else
{
searchStrategy = new NameStrategy();
return(searchStrategy.SearchMuralsWithName(searchParameter));
}
}
public void PrettyPrint()
{
string Tabs = string.Concat(Enumerable.Repeat("| ", RecursionLevel));
Console.WriteLine("{0:s}├ {1:s} ({2:s}) : {3:s} ", Tabs, ModuleName, SearchStrategy.ToString(), Filepath);
foreach (var Dep in Dependencies)
{
if (Root.VisitModule(Dep.ModuleName, Dep.Filepath))
{
Dep.PrettyPrint();
}
}
}
public async Task<IHttpActionResult> Search(
double lat, double lon, string address, double? radius,
int limit = AppConstants.DefaultAssetSearchLimit, SearchStrategy strategy = SearchStrategy.QUICK)
{
var request = new AssetSearchRequest()
{
Location = new DefaultAddress(address, new Data.Model.GeoJson.Point(new double[] { lon, lat }.ToList())),
Limit = limit,
Radius = radius,
Strategy = strategy
};
var result = await provider.FindEligibleAssets(request);
return Ok(result);
}
public void SetSearchStrategy(SearchStrategy strategy)
{
if (strategy.Equals(SearchStrategy.TITLE))
{
this.strategy = new TitleSearch();
}
else if (strategy.Equals(SearchStrategy.AUTHOR))
{
this.strategy = new AuthorSearch();
}
else
{
this.strategy = new IsbnSearch();
}
}
public async Task <IHttpActionResult> Search(
double lat, double lon, string address, double?radius,
int limit = AppConstants.DefaultAssetSearchLimit, SearchStrategy strategy = SearchStrategy.QUICK)
{
var request = new AssetSearchRequest()
{
Location = new DefaultAddress(address, new Data.Model.GeoJson.Point(new double[] { lon, lat }.ToList())),
Limit = limit,
Radius = radius,
Strategy = strategy
};
var result = await provider.FindEligibleAssets(request);
return(Ok(result));
}
public static void Main(string[] args)
{
string input;
Dictionary <uint, Dictionary <uint, Datum> > dataByFeatureAndId;
do
{
Console.WriteLine("Enter the file name (e.g. 'small_data.txt')");
input = Console.ReadLine();
}while (!DataBuilder.BuildData(input, out dataByFeatureAndId));
SearchStrategy searchStrategy = null;
do
{
Console.WriteLine("Select an algorithm:");
input = Console.ReadLine();
if (!ushort.TryParse(input, out ushort value))
{
continue;
}
switch (value)
{
case 1:
{
searchStrategy = ForwardSearchStrategy.Instance;
break;
}
case 2:
{
searchStrategy = BackwardSearchStrategy.Instance;
break;
}
}
}while (searchStrategy == null);
searchStrategy.Search(dataByFeatureAndId);
}
public T FindComponent <T>(SearchStrategy strategy = SearchStrategy.InChildren)
{
var query = new Query
{
Type = typeof(T),
Strategy = strategy
};
if (this.cache.TryGetValue(query, out var result))
{
return((T)result);
}
var component = query.Execute <T>(this.gameObject);
this.cache[query] = component;
return(component);
}
static void Solve(Node Initial)
{
SearchStrategy Strat = null;
Console.WriteLine("Which strategy would you like to use?");
Console.WriteLine("1) Depth First Search");
Console.WriteLine("2) Breadth First Search");
Console.WriteLine("3) Minimize time per day heuristic");
Console.WriteLine("4) Minimize tasks per day heuristic");
Console.WriteLine("5) Simulated Annealing");
int X;
int.TryParse(Console.ReadLine(), out X);
switch (X)
{
case 1:
Strat = new DepthFirstSearch();
break;
case 2:
Strat = new BreadthFirstSearch();
break;
case 3:
Strat = new AStarSearch(new LowTimePerDayHeuristic());
break;
case 4:
Strat = new AStarSearch(new LowTaskPerDayHeuristic());
break;
case 5:
SimulatedAnnealer SA = new SimulatedAnnealer(Initial);
Console.WriteLine(SA.Anneal());
return;
default:
Console.WriteLine("I don't understand, exiting!");
return;
}
Console.WriteLine(Strat.Solve(Initial));
}
private Stack <Action> TreeSearch(Problem p, SearchStrategy strategy)
{
/*
* Arbre de recherche permet de savoir quoi faire
*
*/
Stack <Action> actionList = new Stack <Action>();
Node endNode = strategy.SearchPath(p);
while (endNode != null)
{
if (endNode.action != null)
{
actionList.Push(endNode.action);
}
endNode = endNode.parentNode;
}
actionList.Reverse();
return(actionList);
}
public void PrettyPrint()
{
string Tabs = string.Concat(Enumerable.Repeat("| ", RecursionLevel));
Console.WriteLine("{0:s}├ {1:s} ({2:s}) : {3:s} ", Tabs, ModuleName, SearchStrategy.ToString(), Filepath);
foreach (var Dep in ResolvedImports)
{
bool NeverSeenModule = Root.VisitModule(Dep.ModuleName, Dep.Filepath);
if (NeverSeenModule)
{
Dep.PrettyPrint();
}
else
{
Dep.BasicPrettyPrint();
}
}
}
public ResultDelegate <TSearch, TResult> CreateResultDelegate(LinkedList <CompositPropertyVertex> vertices,
SearchStrategy <TSearch, TResult> strategy)
{
var delegateMap = new Dictionary <CompositPropertyVertex, ProxyDelegate <TSearch, TResult> >();
var delegates = new ProxyDelegate <TSearch, TResult> [vertices.Count];
var index = 0;
vertices.ForEach(
node =>
{
CreateDelegate(node.Value, delegateMap, strategy);
delegates[index++] = delegateMap[node.Value];
});
var rootDelegate = new RootProxyDelegate <TSearch, TResult>(delegates, strategy);
rootDelegate.BuildExecuteChildrenDelegate();
return(rootDelegate.Execute);
}
public State findPath()
{
State result;
switch (Searcher)
{
case Constant.ASTAR:
searchStrategy = new AStar();
result = searchStrategy.findPath(this.start, this.end, this);
break;
case Constant.DFS:
searchStrategy = new DFS();
result = searchStrategy.findPath(this.start, this.end, this);
break;
case Constant.BFS:
searchStrategy = new BFS();
result = searchStrategy.findPath(this.start, this.end, this);
break;
//case Constant.BIDIRECTIONALASTAR:
// searchStrategy = new BiDirectionalAStar();
// result = searchStrategy.findPath(this.start, this.end, this);
// break;
case Constant.DIJKSTRA:
searchStrategy = new Dijkstra();
result = searchStrategy.findPath(this.start, this.end, this);
break;
default:
searchStrategy = new AStar();
result = searchStrategy.findPath(this.start, this.end, this);
break;
}
return(result);
}
private static void CreateDelegate(CompositPropertyVertex vertex,
Dictionary <CompositPropertyVertex, ProxyDelegate <TSearch, TResult> > delegateMap,
SearchStrategy <TSearch, TResult> strategy)
{
if (vertex.PropertyList.First == null)
{
throw new NullReferenceException();
}
if (delegateMap.ContainsKey(vertex))
{
return;
}
var propertyGetters = new Func <object, object> [vertex.PropertyList.Count];
var parameter = Expression.Parameter(typeof(object), "obj");
var nullConst = Expression.Constant(null);
var hasCollection = false;
var index = 0;
vertex.PropertyList.ForEach(
node =>
{
if (typeof(ICollection).IsAssignableFrom(node.Value.PropertyType))
{
hasCollection = true;
}
var resultVariable = Expression.Variable(typeof(object), "result");
var castVariable = Expression.Variable(node.Value.DeclaringType, "value");
var castAs = Expression.TypeAs(parameter, node.Value.DeclaringType);
var castAssign = Expression.Assign(castVariable, castAs);
var checkNotNull = Expression.NotEqual(castVariable, nullConst);
var memberAccess = Expression.Convert(Expression.MakeMemberAccess(castVariable, node.Value),
typeof(object));
var conditionalMemberAccess = Expression.Condition(checkNotNull, memberAccess, nullConst);
var resultAssign = Expression.Assign(resultVariable, conditionalMemberAccess);
var returnTarget = Expression.Label(typeof(object));
var returnLabel = Expression.Label(returnTarget, nullConst);
var returnExpr = Expression.Return(returnTarget, resultVariable);
var block = Expression.Block(typeof(object), new[] { castVariable, resultVariable }, castAssign,
resultAssign, returnExpr, returnLabel);
var deleg = Expression.Lambda <Func <object, object> >(block, parameter).Compile();
propertyGetters[index++] = deleg;
});
var childDelegates = new ProxyDelegate <TSearch, TResult> [vertex.Children.Count];
delegateMap[vertex] = new ProxyDelegate <TSearch, TResult>(propertyGetters, childDelegates, strategy,
hasCollection);
index = 0;
vertex.Children.ForEach(
node =>
{
CreateDelegate(node.Value, delegateMap, strategy);
childDelegates[index++] = delegateMap[node.Value];
});
}
public abstract void Apply(MonoBehaviour behaviour, object obj, FieldInfo field, SearchStrategy searchStrategy);
public void BasicPrettyPrint()
{
string Tabs = string.Concat(Enumerable.Repeat("| ", RecursionLevel));
Console.WriteLine("{0:s}├ {1:s} ({2:s}) : {3:s} ", Tabs, ModuleName, SearchStrategy.ToString(), Filepath);
}
protected AbstractProvider(string someConfigurationFilePath, SearchStrategy someSearchStrategy)
{
setConfiguration(someConfigurationFilePath);
setSearchStrategy(someSearchStrategy ?? getDefaultStrategy());
}
public void SetSearchStrategy(SearchStrategy strategy)
{
this.searchStrategy = strategy;
}
public void SetSearchStrategy(SearchStrategy searchStrategy)
{
_searchStrategy = searchStrategy;
if (SearchStrategyChanged != null)
{
SearchStrategyChanged(this, new EventArgs<SearchStrategy> { Data = searchStrategy });
}
}
public void setSearchStrategy(SearchStrategy newStrategy)
{
if (newStrategy != null) {
searchStrategy = newStrategy;
}
}
private void FindComponentsCustom(SearchStrategy strategy)
{
ComponentFinderAttribute.ApplyAttribute <ComponentFinderAttribute>(this, strategy);
}
protected BaseProxyDelegate(ProxyDelegate <TSearch, TResult>[] children,
SearchStrategy <TSearch, TResult> strategy)
{
Children = children;
_strategy = strategy;
}
