In the year 1996, the signing of a cooperative educational agreement between the Ministry of Education and Culture of the Kyrgyz Republic and the Sebat Educational Organization, gave a start for the launch of the International Atatürk-Ala-too University. The campus area constitutes 54,000m2 covered and 16,000m2 of open space. Five blocks are located on the campus, equipped with smart boards, internet infrastructure, and modern laboratories. In our peaceful campus you can benefit from the use of the library that is a home for 30 thousand books in different languages used in our various study programs. Every day, on weekdays at noon, both delicious and affordable meals are available for 250 people in the big dining hall. Two canteens, with decent environments, serve our students in the winter and summer. An indoor sports hall and football-basketball-volleyball-tennis fields also add to the diversity of our campus. IAAU has four faculties: Economics and Administrative Sciences, Social Sciences, New Technologies and Medicine form the core. Eighteen departments, a professional college that educates 9th through 11th grade students, with a distant educational system consisting of BA (Management) and MA (Pedagogy and Management) programs complete the educational infrastructure, making education available for 2412 students from all over the world. Tuition fees reflect the global standards and vary based on the choice of faculty. Education is conducted mainly in English with Russian, Kyrgyz, and Turkish languages being auxiliary. The university offers selective language courses of Japanese, German, Chinese, and French. Also, for those with insufficient English language proficiency, there is a Preparatory School where English is taught 24/7. The University is a home for young, active and highly qualified teaching staff from different countries like Turkey, Kyrgyzstan, the USA, China, and India. Group advisors are ready to help students through all sorts of problems that a student may come up with. Undergraduate, Master and Doctoral programs are conducted with respect and love in a multicultural and democratic atmosphere. We cooperate with universities in Turkey, the USA, China, Cyprus, and some countries in Europe; Mevlana and Erasmus are the staff and student exchange programs that provide a chance to see the world and be educated according to global standards. Owing to these programs, our academic staff and students are able to exchange experiences, cultural values, and information. Our students are able to be trained at prestigious companies while even being a 2nd- or 3rd-year student. Eighty percent (80%) of our alumni get hired due to the professional knowledge, fluency in languages, computer skills, good aesthetic characteristics, and self-confidence that were cultured with love in our university. In a country like Kyrgyzstan, with a blend of multinational cultural values, beliefs, mutual respect, and a love for nature, the International Atatürk-Alatoo University will wait for you, and our dynamic, young academic staff is ready to educate, prepare, and cultivate in you a global citizen, ready to meet the world.


Or shoot me a message right here and I'll get back to you in 7 business days.
Name
Email
Phone
Message


Select2 is a jQuery based replacement for select boxes. It supports searching, remote data sets, and pagination (infinite scrolling) of results. Read the Official Select2 Documentation for a full list of instructions and other options.
Select2 was designed to be a replacement for the standard <select>
box that is displayed by the browser. By default it supports all options and operations that are available in a standard select box, but with added flexibility.
$('.select2').select2();
Select2 by default does have a search box displayed but most of the time this template uses select2 without a search.
$('.select2').select2({
placeholder: 'Choose one',
searchInputPlaceholder: 'Search options'
});
Select2 will respond to the disabled attribute on select elements. You can also initialize Select2 with disabled: true
to get the same effect.
<select class="form-control select2" disabled>...</select>
Select2 also supports multi-value select boxes. The select below is declared with the multiple attribute.
<select class="form-control select2" multiple="multiple">...</select>
When set to true, causes a clear button close icon to appear on the select box when a value is selected. Clicking the clear button will clear the selected value, effectively resetting the select box back to its placeholder value.
$('.select2').select2({
placeholder: 'Choose one',
allowClear: true
});
Select2 multi-value select boxes can set restrictions regarding the maximum number of options that can be selected.
$('.select2').select2({
placeholder: 'Choose one',
maximumSelectionLength: 2
});


|
|
Part II: Advanced Uses By DmitryKorolev TopCoder Member In this tutorial we will use some macros and typedefs from Part I of the tutorial. Creating Vector from Map Copying Data Between Containers Merging Lists Calculating Algorithms Nontrivial Sorting Using Your Own Objects in Maps and Sets Memory Management in Vectors Implementing Real Algorithms with STL Depth-first Search (DFS) A word on other container types and their usage Queue Breadth-first Search (BFS) Priority_Queue Dijkstra Dijkstra priority_queue Dijkstra by set What Is Not Included in STL Creating Vector from Map As you already know, map actually contains pairs of element. So you can write it in like this: map<string, int> M; // ... vector< pair<string, int> > V(all(M)); // remember all(c) stands for (c).begin(),(c).end()Now vector will contain the same elements as map. Of course, vector will be sorted, as is map. This feature may be useful if you are not planning to change elements in map any more but want to use indices of elements in a way that is impossible in map. Copying data between containers Let's take a look at the copy(...) algorithm. The prototype is the following: copy(from_begin, from_end, to_begin);This algorithm copies elements from the first interval to the second one. The second interval should have enough space available. See the following code: vector<int> v1; vector<int> v2; // ... // Now copy v2 to the end of v1 v1.resize(v1.size() + v2.size()); // Ensure v1 have enough space copy(all(v2), v1.end() - v2.size()); // Copy v2 elements right after v1 onesAnother good feature to use in conjunction with copy is inserters. I will not describe it here due to limited space but look at the code: vector<int> v; // ... set<int> s; // add some elements to set copy(all(v), inserter(s));The last line means: tr(v, it) { // remember traversing macros from Part I s.insert(*it); }But why use our own macros (which work only in gcc) when there is a standard function? It’s a good STL practice to use standard algorithms like copy, because it will be easy to others to understand your code. To insert elemements to vector with push_back use back_inserter, or front_inserter is available for deque container. And in some cases it is useful to remember that the first two arguments for ‘copy’ may be not only begin/end, but also rbegin/rend, which copy data in reverse order. Merging lists Another common task is to operate with sorted lists of elements. Imagine you have two lists of elements -- A and B, both ordered. You want to get a new list from these two. There are four common operations here:
end_result = set_intersection(begin1, end1, begin2, end2, begin_result);Here [begin1,end1) and [begin2,end2) are the input lists. The 'begin_result' is the iterator from where the result will be written. But the size of the result is unknown, so this function returns the end iterator of output (which determines how many elements are in the result). See the example for usage details: int data1[] = { 1, 2, 5, 6, 8, 9, 10 }; int data2[] = { 0, 2, 3, 4, 7, 8, 10 }; vector<int> v1(data1, data1+sizeof(data1)/sizeof(data1[0])); vector<int> v2(data2, data2+sizeof(data2)/sizeof(data2[0])); vector<int> tmp(max(v1.size(), v2.size()); vector<int> res = vector<int> (tmp.begin(), set_intersection(all(v1), all(v2), tmp.begin());Look at the last line. We construct a new vector named 'res'. It is constructed via interval constructor, and the beginning of the interval will be the beginning of tmp. The end of the interval is the result of the set_intersection algorithm. This algorithm will intersect v1 and v2 and write the result to the output iterator, starting from 'tmp.begin()'. Its return value will actually be the end of the interval that forms the resulting dataset. One comment that might help you understand it better: If you would like to just get the number of elements in set intersection, use int cnt = set_intersection(all(v1), all(v2), tmp.begin()) – tmp.begin(); Actually, I would never use a construction like ' vector<int> tmp'. I don't think it's a good idea to allocate memory for each set_*** algorithm invoking. Instead, I define the global or static variable of appropriate type and enough size. See below: set<int> s1, s2; for(int i = 0; i < 500; i++) { s1.insert(i*(i+1) % 1000); s2.insert(i*i*i % 1000); } static int temp[5000]; // greater than we need vector<int> res = vi(temp, set_symmetric_difference(all(s1), all(s2), temp)); int cnt = set_symmetric_difference(all(s1), all(s2), temp) – temp;Here 'res' will contain the symmetric difference of the input datasets. Remember, input datasets need to be sorted to use these algorithms. So, another important thing to remember is that, because sets are always ordered, we can use set-s (and even map-s, if you are not scared by pairs) as parameters for these algorithms. These algorithms work in single pass, in O(N1+N2), when N1 and N2 are sizes of input datasets. Calculating Algorithms Yet another interesting algorithm is accumulate(...). If called for a vector of int-s and third parameter zero, accumulate(...) will return the sum of elements in vector: vector<int> v; // ... int sum = accumulate(all(v), 0);The result of accumulate() call always has the type of its third argument. So, if you are not sure that the sum fits in integer, specify the third parameter's type directly: vector<int> v; // ... long long sum = accumulate(all(v), (long long)0);Accumulate can even calculate the product of values. The fourth parameter holds the predicate to use in calculations. So, if you want the product: vector<int> v; // ... double product = accumulate(all(v), double(1), multiplies<double>()); // don’t forget to start with 1 !Another interesting algorithm is inner_product(...). It calculates the scalar product of two intervals. For example: vector<int> v1; vector<int> v2; for(int i = 0; i < 3; i++) { v1.push_back(10-i); v2.push_back(i+1); } int r = inner_product(all(v1), v2.begin(), 0);'r' will hold (v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]), or (10*1+9*2+8*3), which is 52. As for ‘accumulate’ the type of return value for inner_product is defined by the last parameter. The last parameter is the initial value for the result. So, you may use inner_product for the hyperplane object in multidimensional space: just write inner_product(all(normal), point.begin(), -shift). It should be clear to you now that inner_product requires only increment operation from iterators, so queues and sets can also be used as parameters. Convolution filter, for calculating the nontrivial median value, could look like this: set<int> values_ordered_data(all(data)); int n = sz(data); // int n = int(data.size()); vector<int> convolution_kernel(n); for(int i = 0; i < n; i++) { convolution_kernel[i] = (i+1)*(n-i); } double result = double(inner_product(all(ordered_data), convolution_kernel.begin(), 0)) / accumulate(all(convolution_kernel), 0);Of course, this code is just an example -- practically speaking, it would be faster to copy values to another vector and sort it. It's also possible to write a construction like this: vector<int> v; // ... int r = inner_product(all(v), v.rbegin(), 0);This will evaluate V[0]*V[N-1] + V[1]+V[N-2] + ... + V[N-1]*V[0] where N is the number of elements in 'v'. Nontrivial Sorting Actually, sort(...) uses the same technique as all STL:
struct fraction { int n, d; // (n/d) // ... bool operator < (const fraction& f) const { if(false) { return (double(n)/d) < (double(f.n)/f.d); // Try to avoid this, you're the TopCoder! } else { return n*f.d < f.n*d; } } }; // ... vector<fraction> v; // ... sort(all(v));In cases of nontrivial fields, your object should have default and copy constructor (and, maybe, assignment operator -- but this comment is not for TopCoders). Remember the prototype of 'operator <' : return type bool, const modifier, parameter const reference. Another possibility is to create the comparison functor. Special comparison predicate may be passed to the sort(...) algorithm as a third parameter. Example: sort points (that are pair<double,double>) by polar angle. typedef pair<double, double> dd; const double epsilon = 1e-6; struct sort_by_polar_angle { dd center; // Constuctor of any type // Just find and store the center template<typename T> sort_by_polar_angle(T b, T e) { int count = 0; center = dd(0,0); while(b != e) { center.first += b->first; center.second += b->second; b++; count++; } double k = count ? (1.0/count) : 0; center.first *= k; center.second *= k; } // Compare two points, return true if the first one is earlier // than the second one looking by polar angle // Remember, that when writing comparator, you should // override not ‘operator <’ but ‘operator ()’ bool operator () (const dd& a, const dd& b) const { double p1 = atan2(a.second-center.second, a.first-center.first); double p2 = atan2(b.second-center.second, b.first-center.first); return p1 + epsilon < p2; } }; // ... vector<dd> points; // ... sort(all(points), sort_by_polar_angle(all(points)));This code example is complex enough, but it does demonstrate the abilities of STL. I should point out that, in this sample, all code will be inlined during compilation, so it's actually really fast. Also remember that 'operator <' should always return false for equal objects. It's very important – for the reason why, see the next section. Using your own objects in Maps and Sets Elements in set and map are ordered. It's the general rule. So, if you want to enable using of your objects in set or map you should make them comparable. You already know the rule of comparisons in STL: | * all comparison is based on 'operator <' Again, you should understand it in this way: "I only need to implement operator < for objects to be stored in set/map." Imagine you are going to make the 'struct point' (or 'class point'). We want to intersect some line segments and make a set of intersection points (sound familiar?). Due to finite computer precision, some points will be the same while their coordinates differ a bit. That's what you should write: const double epsilon = 1e-7; struct point { double x, y; // ... // Declare operator < taking precision into account bool operator < (const point& p) const { if(x < p.x - epsilon) return true; if(x > p.x + epsilon) return false; if(y < p.y - epsilon) return true; if(y > p.y + epsilon) return false; return false; } };Now you can use set<point> or map<point, string>, for example, to look up whether some point is already present in the list of intersections. An even more advanced approach: use map<point, vector<int> > and list the list of indices of segments that intersect at this point. It's an interesting concept that for STL 'equal' does not mean 'the same', but we will not delve into it here. Memory management in Vectors As has been said, vector does not reallocate memory on each push_back(). Indeed, when push_back() is invoked, vector really allocates more memory than is needed for one additional element. Most STL implementations of vector double in size when push_back() is invoked and memory is not allocated. This may not be good in practical purposes, because your program may eat up twice as much memory as you need. There are two easy ways to deal with it, and one complex way to solve it. The first approach is to use the reserve() member function of vector. This function orders vector to allocate additional memory. Vector will not enlarge on push_back() operations until the size specified by reserve() will be reached. Consider the following example. You have a vector of 1,000 elements and its allocated size is 1024. You are going to add 50 elements to it. If you call push_back() 50 times, the allocated size of vector will be 2048 after this operation. But if you write v.reserve(1050);before the series of push_back(), vector will have an allocated size of exactly 1050 elements. If you are a rapid user of push_back(), then reserve() is your friend. By the way, it’s a good pattern to use v.reserve() followed by copy(…, back_inserter(v)) for vectors. Another situation: after some manipulations with vector you have decided that no more adding will occur to it. How do you get rid of the potential allocation of additional memory? The solution follows: vector<int> v; // ... vector<int>(all(v)).swap(v);This construction means the following: create a temporary vector with the same content as v, and then swap this temporary vector with 'v'. After the swap the original oversized v will be disposed. But, most likely, you won’t need this during SRMs. The proper and complex solution is to develop your own allocator for the vector, but that's definitely not a topic for a TopCoder STL tutorial. Implementing real algorithms with STL Armed with STL, let's go on to the most interesting part of this tutorial: how to implement real algorithms efficiently. Depth-first search (DFS) I will not explain the theory of DFS here – instead, read this section of gladius's Introduction to Graphs and Data Structures tutorial – but I will show you how STL can help. At first, imagine we have an undirected graph. The simplest way to store a graph in STL is to use the lists of vertices adjacent to each vertex. This leads to the vector< vector<int> > W structure, where W[i] is a list of vertices adjacent to i. Let’s verify our graph is connected via DFS: /* Reminder from Part 1: typedef vector<int> vi; typedef vector<vi> vvi; */ int N; // number of vertices vvi W; // graph vi V; // V is a visited flag void dfs(int i) { if(!V[i]) { V[i] = true; for_each(all(W[i]), dfs); } } bool check_graph_connected_dfs() { int start_vertex = 0; V = vi(N, false); dfs(start_vertex); return (find(all(V), 0) == V.end()); }That’s all. STL algorithm 'for_each' calls the specified function, 'dfs', for each element in range. In check_graph_connected() function we first make the Visited array (of correct size and filled with zeroes). After DFS we have either visited all vertices, or not – this is easy to determine by searching for at least one zero in V, by means of a single call to find(). Notice on for_each: the last argument of this algorithm can be almost anything that “can be called like a function”. It may be not only global function, but also adapters, standard algorithms, and even member functions. In the last case, you will need mem_fun or mem_fun_ref adapters, but we will not touch on those now. One note on this code: I don't recommend the use of vector<bool>. Although in this particular case it’s quite safe, you're better off not to use it. Use the predefined ‘vi’ (vector<int>). It’s quite OK to assign true and false to int’s in vi. Of course, it requires 8*sizeof(int)=8*4=32 times more memory, but it works well in most cases and is quite fast on TopCoder. A word on other container types and their usage Vector is so popular because it's the simplest array container. In most cases you only require the functionality of an array from vector – but, sometimes, you may need a more advanced container. It is not good practice to begin investigating the full functionality of some STL container during the heat of a Single Round Match. If you are not familiar with the container you are about to use, you'd be better off using vector or map/set. For example, stack can always be implemented via vector, and it’s much faster to act this way if you don’t remember the syntax of stack container. STL provides the following containers: list, stack, queue, deque, priority_queue. I’ve found list and deque quite useless in SRMs (except, probably, for very special tasks based on these containers). But queue and priority_queue are worth saying a few words about. Queue Queue is a data type that has three operations, all in O(1) amortized: add an element to front (to “head”) remove an element from back (from “tail”) get the first unfetched element (“tail”) In other words, queue is the FIFO buffer. Breadth-first search (BFS) Again, if you are not familiar with the BFS algorithm, please refer back to this TopCoder tutorial first. Queue is very convenient to use in BFS, as shown below: /* Graph is considered to be stored as adjacent vertices list. Also we considered graph undirected. vvi is vector< vector<int> > W[v] is the list of vertices adjacent to v */ int N; // number of vertices vvi W; // lists of adjacent vertices bool check_graph_connected_bfs() { int start_vertex = 0; vi V(N, false); queue<int> Q; Q.push(start_vertex); V[start_vertex] = true; while(!Q.empty()) { int i = Q.front(); // get the tail element from queue Q.pop(); tr(W[i], it) { if(!V[*it]) { V[*it] = true; Q.push(*it); } } } return (find(all(V), 0) == V.end()); }More precisely, queue supports front(), back(), push() (== push_back()), pop (== pop_front()). If you also need push_front() and pop_back(), use deque. Deque provides the listed operations in O(1) amortized. There is an interesting application of queue and map when implementing a shortest path search via BFS in a complex graph. Imagine that we have the graph, vertices of which are referenced by some complex object, like: pair< pair<int,int>, pair< string, vector< pair<int, int> > > > (this case is quite usual: complex data structure may define the position in some game, Rubik’s cube situation, etc…)Consider we know that the path we are looking for is quite short, and the total number of positions is also small. If all edges of this graph have the same length of 1, we could use BFS to find a way in this graph. A section of pseudo-code follows: // Some very hard data structure typedef pair< pair<int,int>, pair< string, vector< pair<int, int> > > > POS; // ... int find_shortest_path_length(POS start, POS finish) { map<POS, int> D; // shortest path length to this position queue<POS> Q; D[start] = 0; // start from here Q.push(start); while(!Q.empty()) { POS current = Q.front(); // Peek the front element Q.pop(); // remove it from queue int current_length = D[current]; if(current == finish) { return D[current]; // shortest path is found, return its length } tr(all possible paths from 'current', it) { if(!D.count(*it)) { // same as if(D.find(*it) == D.end), see Part I // This location was not visited yet D[*it] = current_length + 1; } } } // Path was not found return -1; } // ...If the edges have different lengths, however, BFS will not work. We should use Dijkstra instead. It's possible to implement such a Dijkstra via priority_queue -- see below. Priority_Queue Priority queue is the binary heap. It's the data structure, that can perform three operations:
Dijkstra In the last part of this tutorial I’ll describe how to efficiently implement Dijktra’s algorithm in sparse graph using STL containers. Please look through this tutorial for information on Dijkstra’s algoritm. Consider we have a weighted directed graph that is stored as vector< vector< pair<int,int> > > G, where
typedef pair<int,int> ii; typedef vector<ii> vii; typedef vector<vii> vvii;Dijstra via priority_queue Many thanks to misof for spending the time to explain to me why the complexity of this algorithm is good despite not removing deprecated entries from the queue. vi D(N, 987654321); // distance from start vertex to each vertex priority_queue<ii,vector<ii>, greater<ii> > Q; // priority_queue with reverse comparison operator, // so top() will return the least distance // initialize the start vertex, suppose it’s zero D[0] = 0; Q.push(ii(0,0)); // iterate while queue is not empty while(!Q.empty()) { // fetch the nearest element ii top = Q.top(); Q.pop(); // v is vertex index, d is the distance int v = top.second, d = top.first; // this check is very important // we analyze each vertex only once // the other occurrences of it on queue (added earlier) // will have greater distance if(d <= D[v]) { // iterate through all outcoming edges from v tr(G[v], it) { int v2 = it->first, cost = it->second; if(D[v2] > D[v] + cost) { // update distance if possible D[v2] = D[v] + cost; // add the vertex to queue Q.push(ii(D[v2], v2)); } } } }I will not comment on the algorithm itself in this tutorial, but you should notice the priority_queue object definition. Normally, priority_queue<ii> will work, but the top() member function will return the largest element, not the smallest. Yes, one of the easy solutions I often use is just to store not distance but (-distance) in the first element of a pair. But if you want to implement it in the “proper” way, you need to reverse the comparison operation of priority_queue to reverse one. Comparison function is the third template parameter of priority_queue while the second paramerer is the storage type for container. So, you should write priority_queue<ii, vector<ii>, greater<ii> >. Dijkstra via set Petr gave me this idea when I asked him about efficient Dijkstra implementation in C#. While implementing Dijkstra we use the priority_queue to add elements to the “vertices being analyzed” queue in O(logN) and fetch in O(log N). But there is a container besides priority_queue that can provide us with this functionality -- it’s ‘set’! I’ve experimented a lot and found that the performance of Dijkstra based on priority_queue and set is the same. So, here’s the code: vi D(N, 987654321); // start vertex set<ii> Q; D[0] = 0; Q.insert(ii(0,0)); while(!Q.empty()) { // again, fetch the closest to start element // from “queue” organized via set ii top = *Q.begin(); Q.erase(Q.begin()); int v = top.second, d = top.first; // here we do not need to check whether the distance // is perfect, because new vertices will always // add up in proper way in this implementation tr(G[v], it) { int v2 = it->first, cost = it->second; if(D[v2] > D[v] + cost) { // this operation can not be done with priority_queue, // because it does not support DECREASE_KEY if(D[v2] != 987654321) { Q.erase(Q.find(ii(D[v2],v2))); } D[v2] = D[v] + cost; Q.insert(ii(D[v2], v2)); } } }One more important thing: STL’s priority_queue does not support the DECREASE_KEY operation. If you will need this operation, ‘set’ may be your best bet. I’ve spent a lot of time to understand why the code that removes elements from queue (with set) works as fast as the first one. These two implementations have the same complexity and work in the same time. Also, I’ve set up practical experiments and the performance is exactly the same (the difference is about ~%0.1 of time). As for me, I prefer to implement Dijkstra via ‘set’ because with ‘set’ the logic is simpler to understand, and we don’t need to remember about ‘greater<int>’ predicate overriding. What is not included in STL If you have made it this far in the tutorial, I hope you have seen that STL is a very powerful tool, especially for TopCoder SRMs. But before you embrace STL wholeheartedly, keep in mind what is NOT included in it. First, STL does not have BigInteger-s. If a task in an SRM calls for huge calculations, especially multiplication and division, you have three options:
Nearly the same issue arises with the geometry library. STL does not have geometry support, so you have those same three options again. The last thing – and sometimes a very annoying thing – is that STL does not have a built-in string splitting function. This is especially annoying, given that this function is included in the default template for C++ in the ExampleBuilder plugin! But actually I’ve found that the use of istringstream(s) in trivial cases and sscanf(s.c_str(), …) in complex cases is sufficient. Those caveats aside, though, I hope you have found this tutorial useful, and I hope you find the STL a useful addition to your use of C++. Best of luck to you in the Arena! Note from the author: In both parts of this tutorial I recommend the use of some templates to minimize the time required to implement something. I must say that this suggestion should always be up to the coder. Aside from whether templates are a good or bad tactic for SRMs, in everyday life they can become annoying for other people who are trying to understand your code. While I did rely on them for some time, ultimately I reached the decision to stop. I encourage you to weigh the pros and cons of templates and to consider this decision for yourself.
|
|
|
Home |
About TopCoder |
Press Room |
Contact Us |
Careers |
Privacy |
Terms
Competitions | Cockpit |
| Copyright TopCoder, Inc. 2001-2011 |


Logged as Mark Log Out
BUZZ CALLISTER ACCEPT | DENY
JIM CALLISTER ACCEPT | DENY
JERRY CALLISTER ACCEPT | DENY
TERRY CALLISTER ACCEPT | DENY


The ARCHDUX Forum cordially invites enthusiasts, architects, designers, architecture students and professionals with varied backgrounds from all around the world as we stand under a single umbrella with a commitment to change perspectives in architecture by collecting the best outcomes from a diverse range of creative and innovative minds.
TAKING BUSINESS TO WORLD. Yes, we are on a Mission. We always wanted digital space to grow and with the latest focus of our current Prime Minister Mr. Narendra Modi on Digital India, We are inching towards helping brands and identities attain new heights and grow digitally.
We are not an industry with a 20-20 vision, we are focused on quality. Our vision is to give quality work at the best possible price. One thing that sets Atishay apart from its competitors is that extra mile. Yes Atishay is willing to take that extra step to satisfy its customers.
We always have different strategies in Mind. At first we take the inputs from the client and get to know there exact requirements. On the basis of that we show our clients some samples from which they can choose from, after the website is made as per taste of our client, we proceed to make it live. But hey our work does not end there. We then take a proper feedback and imply changes even after the work is done and fully complete.
“Excellent response, i loved their work a lot. i had some of my own idea which i thought would look good but he guided me about the recent scenario and came up with some really good work aayush is very helpful person, he guided me in every other needs during the process i.e photography ,logo etc. prizes are really good loved their work and response
“He did content writing and website development for my companies profile. He did a brilliant job. everything was done on time and was done as it was expected. They are one the best web designers in delhi. They created an awesome business website.


Tabs are great for separating content. Ours can have text, icons or even images, and are super easy to use.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
This is the accordion content. You can add any content you want to it. Really, anything!
This accordion holds an image. The best part of it? The image is preloaded, so it won't load if you don't expand the accordion. Great for making your page load much faster.
This accordion holds an embeded YouTube video. As we said, add anything to them, they are limitless
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
This is the accordion content. You can add any content you want to it. Really, anything!
This accordion holds an image. The best part of it? The image is preloaded, so it won't load if you don't expand the accordion. Great for making your page load much faster.
This accordion holds an embeded YouTube video. As we said, add anything to them, they are limitless
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
This is the accordion content. You can add any content you want to it. Really, anything!
This accordion holds an image. The best part of it? The image is preloaded, so it won't load if you don't expand the accordion. Great for making your page load much faster.
This accordion holds an embeded YouTube video. As we said, add anything to them, they are limitless
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.


maxime (Tue, 16 Oct 2018 06:19:18 GMT):
Has joined the channel.
amaury.masson (Thu, 25 Oct 2018 13:44:19 GMT):
Has joined the channel.
gabriel.plassat (Wed, 31 Oct 2018 08:37:59 GMT):
@anthony_lelarge bienvenue
jeremie.almosni (Fri, 09 Nov 2018 15:57:44 GMT):
Has joined the channel.
jeremie.almosni (Fri, 09 Nov 2018 16:00:10 GMT):
Bonjour, pourriez-vous me donner le lien vers la communauté d'intérêt pour l'AAP MaaS ? des questions de Via ID qui souhaite entrer en connexions avec les territoires intéressés. merci
gabriel.plassat (Fri, 09 Nov 2018 19:15:35 GMT):
Nous avons mis toutes les infos dans le forum https://forum.fabmob.io/t/repondre-a-lami-experimentation-pour-le-developpement-de-la-mobilite-servicielle-maas/
gabriel.plassat (Fri, 09 Nov 2018 19:16:01 GMT):
Avec notamment les dates des échanges organisés par les pôles de compétitivité
jeremie.almosni (Wed, 14 Nov 2018 08:16:03 GMT):
Merci @gabriel.plassat
laurent_chevereau (Thu, 06 Dec 2018 14:44:03 GMT):
Has joined the channel.
gabriel.plassat (Wed, 31 Jul 2019 13:43:09 GMT):
Room name changed to: projets_maas by gabriel.plassat
gabriel.plassat (Wed, 31 Jul 2019 13:43:09 GMT):
discussion sur le MAAS
Caubel (Tue, 10 Mar 2020 16:54:31 GMT):
Has joined the channel.
laura.foglia (Tue, 10 Mar 2020 17:10:11 GMT):
Has joined the channel.
Jean.ROBERT (Tue, 10 Mar 2020 17:59:43 GMT):
Has joined the channel.
yann.tremeac (Thu, 12 Mar 2020 12:19:20 GMT):
Has joined the channel.
jerome-poyet (Mon, 16 Mar 2020 14:16:45 GMT):
Has joined the channel.
laurence.mechin (Mon, 16 Mar 2020 14:32:31 GMT):
Has joined the channel.
mireille (Mon, 16 Mar 2020 14:34:07 GMT):
Has joined the channel.
pierre.taillant (Mon, 16 Mar 2020 14:47:09 GMT):
Has joined the channel.
remy.leboennec (Mon, 16 Mar 2020 15:27:47 GMT):
Has joined the channel.
lara.hoelting (Tue, 17 Mar 2020 13:31:29 GMT):
Has joined the channel.
nicolas.lb (Fri, 20 Mar 2020 10:47:50 GMT):
Has joined the channel.
kmog (Fri, 20 Mar 2020 11:55:29 GMT):
Has joined the channel.
lea.chretien (Fri, 20 Mar 2020 15:19:08 GMT):
Has joined the channel.
paul_bridier (Fri, 20 Mar 2020 16:09:00 GMT):
Has joined the channel.
Yao (Fri, 20 Mar 2020 19:07:51 GMT):
Has joined the channel.
cecile.lavernhe (Mon, 23 Mar 2020 09:37:29 GMT):
Has joined the channel.
marc.cottignies (Mon, 23 Mar 2020 10:30:14 GMT):
Has joined the channel.
sandrine.carballes (Mon, 23 Mar 2020 10:50:22 GMT):
Has joined the channel.
Kiki (Mon, 23 Mar 2020 13:05:52 GMT):
Has joined the channel.
louise.kold-taylor (Mon, 23 Mar 2020 18:31:54 GMT):
Has joined the channel.
ClaraB (Sun, 29 Mar 2020 15:05:13 GMT):
Has joined the channel.
emmanuel.poisson-quinton (Mon, 30 Mar 2020 08:54:32 GMT):
Has joined the channel.
Cath (Mon, 30 Mar 2020 18:46:58 GMT):
Has joined the channel.
pony (Wed, 01 Apr 2020 09:23:40 GMT):
Has joined the channel.
salvatore.cimmino (Fri, 03 Apr 2020 13:51:37 GMT):
Has joined the channel.
karine (Sat, 04 Apr 2020 19:51:30 GMT):
Has joined the channel.
camillem (Sun, 05 Apr 2020 18:35:45 GMT):
Has joined the channel.
jonatan.cloutier (Tue, 07 Apr 2020 20:47:35 GMT):
Has joined the channel.
marie-pierre.gendron (Fri, 10 Apr 2020 14:42:05 GMT):
Has joined the channel.
Jesse (Fri, 10 Apr 2020 20:41:12 GMT):
Has joined the channel.
gontrand.dumont (Fri, 10 Apr 2020 20:55:01 GMT):
Has joined the channel.
xavier.massicotte (Fri, 10 Apr 2020 21:00:36 GMT):
Has joined the channel.
clem (Fri, 10 Apr 2020 21:28:11 GMT):
Has joined the channel.
marie.tack (Fri, 10 Apr 2020 21:52:00 GMT):
Has joined the channel.
Ysaia (Sat, 11 Apr 2020 01:32:32 GMT):
Has joined the channel.
ameliepb (Sat, 11 Apr 2020 14:18:09 GMT):
Has joined the channel.
laurent.lewis (Sun, 12 Apr 2020 16:22:41 GMT):
Has joined the channel.
Amelie (Sun, 12 Apr 2020 22:36:33 GMT):
Has joined the channel.
Amelie (Sun, 12 Apr 2020 22:39:54 GMT):
Has left the channel.
maude.lapointe (Mon, 13 Apr 2020 15:33:30 GMT):
Has joined the channel.
melissa.dlf (Mon, 13 Apr 2020 16:04:06 GMT):
Has joined the channel.
eva.murith (Mon, 13 Apr 2020 18:27:03 GMT):
Has joined the channel.
mathieu.couture (Mon, 13 Apr 2020 19:23:57 GMT):
Has joined the channel.
penelope.stuart (Mon, 13 Apr 2020 19:32:11 GMT):
Has joined the channel.
guillaume.fortin (Mon, 13 Apr 2020 19:34:23 GMT):
Has joined the channel.
chloe.fortier.devin (Mon, 13 Apr 2020 19:36:22 GMT):
Has joined the channel.
Romain_Gayet (Mon, 13 Apr 2020 19:37:26 GMT):
Has joined the channel.
nestel.jeremie (Tue, 14 Apr 2020 09:23:55 GMT):
Has joined the channel.
HeleneCauchoix (Tue, 14 Apr 2020 18:50:35 GMT):
Has joined the channel.
marie-helene.beaudry (Tue, 14 Apr 2020 22:35:31 GMT):
Has joined the channel.
mathieu.couture (Wed, 15 Apr 2020 14:12:28 GMT):
Has left the channel.
alexandre g (Fri, 17 Apr 2020 10:04:32 GMT):
Has joined the channel.
test_du_nouveau_bouton (Fri, 17 Apr 2020 13:01:05 GMT):
Has joined the channel.
ju.tav (Fri, 17 Apr 2020 16:34:01 GMT):
Has joined the channel.
Arthur (Fri, 17 Apr 2020 16:43:01 GMT):
Has joined the channel.
Pierre_Lagrandmaison (Mon, 20 Apr 2020 14:48:33 GMT):
Has joined the channel.
diana.borda (Wed, 22 Apr 2020 02:01:20 GMT):
Has joined the channel.
marie-reine.roy (Thu, 23 Apr 2020 13:00:41 GMT):
Has joined the channel.
ValerieM (Thu, 23 Apr 2020 16:47:02 GMT):
Has joined the channel.
melanie.marceau-d (Fri, 24 Apr 2020 15:33:28 GMT):
Has joined the channel.
cynthia.hamel-kropf (Sun, 26 Apr 2020 20:33:47 GMT):
Has joined the channel.
BENOIT_TROUVE (Mon, 27 Apr 2020 06:16:37 GMT):
Has joined the channel.
ali.saidi (Mon, 27 Apr 2020 20:08:18 GMT):
Has joined the channel.
AnneJulie_AB (Mon, 27 Apr 2020 22:22:55 GMT):
Has joined the channel.
alexandre.barreto (Tue, 28 Apr 2020 07:17:03 GMT):
Has joined the channel.
thierry.lachapelle (Tue, 28 Apr 2020 12:27:37 GMT):
Has joined the channel.
clement (Tue, 28 Apr 2020 17:37:13 GMT):
Has joined the channel.
helene.dimanche (Tue, 28 Apr 2020 20:28:58 GMT):
Has joined the channel.
Julie-Scheid (Wed, 29 Apr 2020 14:27:14 GMT):
Has joined the channel.
veloma (Wed, 29 Apr 2020 18:55:39 GMT):
Has joined the channel.
leandre (Wed, 29 Apr 2020 23:06:08 GMT):
Has joined the channel.
camille.jolain (Fri, 01 May 2020 01:54:00 GMT):
Has joined the channel.
johanne.belle-isle (Fri, 01 May 2020 17:07:03 GMT):
Has joined the channel.
RPP-Ysaia-Melanie-Chloe (Fri, 01 May 2020 18:53:46 GMT):
Has joined the channel.
damien.lhouillier (Mon, 04 May 2020 14:00:00 GMT):
Has joined the channel.
tqmn (Mon, 04 May 2020 16:12:38 GMT):
Has joined the channel.
pierre-andre.horth (Tue, 12 May 2020 13:07:51 GMT):
Has joined the channel.
paola.diaz (Mon, 06 Jul 2020 12:05:13 GMT):
Has joined the channel.
paola.diaz (Mon, 06 Jul 2020 12:05:17 GMT):
https://www.businesswire.com/news/home/20200630005277/en/Cubic-Moovit-Redefine-Mobile-Engagement-Travelers
juliendelabaca64 (Thu, 30 Jul 2020 11:11:24 GMT):
Has joined the channel.
fred (Thu, 30 Jul 2020 11:11:24 GMT):
Has joined the channel.
jorge (Thu, 30 Jul 2020 11:11:24 GMT):
Has joined the channel.
15marches (Thu, 30 Jul 2020 11:11:24 GMT):
Has joined the channel.


Here are some performance numbers from an example desktop machine, taken from a version of time_hash_map that was instrumented to also report memory allocation information (this modification is not included by default because it required a big hack to do, including modifying the STL code to not try to do its own freelist management).
Note there are lots of caveats on these numbers: they may differ from machine to machine and compiler to compiler, and they only test a very particular usage pattern that may not match how you use hashtables -- for instance, they test hashtables with very small keys. However, they're still useful for a baseline comparison of the various hashtable implementations.
These figures are from a 2.80GHz Pentium 4 with 2G of memory. The 'standard' hash_map and map implementations are the SGI STL code included with gcc2. Compiled with gcc2.95.3 -g -O2
====== Average over 10000000 iterations Wed Dec 8 14:56:38 PST 2004 SPARSE_HASH_MAP: map_grow 665 ns map_predict/grow 303 ns map_replace 177 ns map_fetch 117 ns map_remove 192 ns memory used in map_grow 84.3956 Mbytes DENSE_HASH_MAP: map_grow 84 ns map_predict/grow 22 ns map_replace 18 ns map_fetch 13 ns map_remove 23 ns memory used in map_grow 256.0000 Mbytes STANDARD HASH_MAP: map_grow 162 ns map_predict/grow 107 ns map_replace 44 ns map_fetch 22 ns map_remove 124 ns memory used in map_grow 204.1643 Mbytes STANDARD MAP: map_grow 297 ns map_predict/grow 282 ns map_replace 113 ns map_fetch 113 ns map_remove 238 ns memory used in map_grow 236.8081 Mbytes
For good performance, the Google hash routines depend on a good hash function: one that distributes data evenly. Many hashtable implementations come with sub-optimal hash functions that can degrade performance. For instance, the hash function given in Knuth's _Art of Computer Programming_, and the default string hash function in SGI's STL implementation, both distribute certain data sets unevenly, leading to poor performance.
As an example, in one test of the default SGI STL string hash function against the Hsieh hash function (see below), for a particular set of string keys, the Hsieh function resulted in hashtable lookups that were 20 times as fast as the STLPort hash function. The string keys were chosen to be "hard" to hash well, so these results may not be typical, but they are suggestive.
There has been much research over the years into good hash functions. Here are some hash functions of note.


| goog.ui.ControlRenderer | |
| goog.ui.ButtonRenderer | goog.ui.ControlRenderer |
| goog.ui.CustomButtonRenderer | goog.ui.ButtonRenderer |
| goog.ui.style.app.ButtonRenderer | goog.ui.CustomButtonRenderer |
| goog.ui.style.app.MenuButtonRenderer | goog.ui.style.app.ButtonRenderer |
| goog.ui.style.app.PrimaryActionButtonRenderer | goog.ui.style.app.ButtonRenderer |
|
createButton(content, dom)
⇒
Takes a text caption or existing DOM structure, and returns the content
wrapped in a pseudo-rounded-corner box. Creates the following DOM structure:
Contents...
Arguments:
Returns:
Pseudo-rounded-corner box containing the content.
|
code » | |||
|
createDom()
⇒
Returns the button's contents wrapped in the following DOM structure:
Contents...
Returns:
Root element for the button.
|
code » | |||
|
getContentElement(element)
No description.
Arguments:
|
code » | |||
|
getCssClass()
No description.
|
code » | |||
|
getIe6ClassCombinations()
No description.
|
code » | |||
|
getStructuralCssClass()
No description.
|
code » | |||
|
hasBoxStructure(button, element)
⇒
Check if the button's element has a box structure.
Arguments:
Returns:
Whether the element has a box structure.
|
code » |
|
canDecorate(element)
⇒
Returns true if this renderer can decorate the element. Overrides
goog.ui.ButtonRenderer#canDecorate by returning true if the
element is a DIV, false otherwise.
|
code » | |||
|
createButton(content, dom)
⇒
Takes a text caption or existing DOM structure, and returns the content
wrapped in a pseudo-rounded-corner box. Creates the following DOM structure:
Contents...
Arguments:
Returns:
Pseudo-rounded-corner box containing the content.
|
code » | |||
|
createDom(button)
⇒
Returns the button's contents wrapped in the following DOM structure:
Contents...
Arguments:
Returns:
Root element for the button.
|
code » | |||
|
decorate(button, element)
⇒
Takes an existing element and decorates it with the custom button control.
Initializes the control's ID, content, tooltip, value, and state based
on the ID of the element, its child nodes, and its CSS classes, respectively.
Returns the element. Overrides goog.ui.ButtonRenderer#decorate.
Arguments:
Returns:
Decorated element.
|
code » | |||
|
getContentElement(element)
⇒
Takes the button's root element and returns the parent element of the
button's contents. Overrides the superclass implementation by taking
the nested DIV structure of custom buttons into account.
|
code » | |||
|
getCssClass()
⇒
Returns the CSS class to be applied to the root element of components
rendered using this renderer.
Returns:
Renderer-specific CSS class.
|
code » | |||
|
hasBoxStructure(button, element)
⇒
Check if the button's element has a box structure.
Arguments:
Returns:
Whether the element has a box structure.
|
code » |
|
createDom(button)
No description.
Arguments:
|
code » | |||
|
decorate(button, element)
No description.
Arguments:
|
code » | |||
|
getAriaRole()
⇒
goog.dom.a11y.Role | undefined
Returns the ARIA role to be applied to buttons.
Returns:
goog.dom.a11y.Role | undefined
ARIA role.
|
code » | |||
|
getCssClass()
No description.
|
code » | |||
|
getTooltip(element)
⇒
Takes a button's root element, and returns its tooltip text.
|
code » | |||
|
getValue()
⇒
Takes a button's root element, and returns the value associated with it.
No-op in the base class.
Returns:
The button's value (undefined if none).
|
code » | |||
|
setCollapsed(button, sides)
Collapses the border on one or both sides of the button, allowing it to be
combined with the adjacent button(s), forming a single UI componenet with
multiple targets.
Arguments:
|
code » | |||
|
setTooltip(element, tooltip)
Takes a button's root element and a tooltip string, and updates the element
with the new tooltip.
|
code » | |||
|
setValue()
Takes a button's root element and a value, and updates the element to reflect
the new value. No-op in the base class.
|
code » | |||
|
updateAriaState(element, state, enable)
Updates the button's ARIA (accessibility) state on Gecko if the button
is being treated as a checkbox.
|
code » |
|
canDecorate(element)
⇒
Returns true if this renderer can decorate the element, false otherwise.
The default implementation always returns true.
|
code » | ||||
|
createClassByStateMap_()
Creates the lookup table of states to classes, used during state changes.
|
code » | ||||
|
createDom(control)
⇒
Returns the control's contents wrapped in a DIV, with the renderer's own
CSS class and additional state-specific classes applied to it.
Arguments:
Returns:
Root element for the control.
|
code » | ||||
|
createStateByClassMap_()
Creates the lookup table of classes to states, used during decoration.
|
code » | ||||
|
decorate(control, element)
⇒
Default implementation of
decorate for goog.ui.Controls.
Initializes the control's ID, content, and state based on the ID of the
element, its child nodes, and its CSS classes, respectively. Returns the
element.
Arguments:
Returns:
Decorated element.
|
code » | ||||
|
enableClassName(control, className, enable)
Updates the control's DOM by adding or removing the specified class name
to/from its root element. May add additional combined classes as needed in
IE6 and lower. Because of this, subclasses should use this method when
modifying class names on the control's root element.
Arguments:
|
code » | ||||
|
enableExtraClassName(control, className, enable)
Updates the control's DOM by adding or removing the specified extra class
name to/from its element.
Arguments:
|
code » | ||||
|
Returns an array of all the combined class names that should be applied based
on the given list of classes. Checks the result of
getIe6ClassCombinations for any combinations that have all
members contained in classes. If a combination matches, the members are
joined with an underscore (in order), and added to the return array.
If opt_includedClass is provided, return only the combined classes that have
all members contained in classes AND include opt_includedClass as well.
opt_includedClass is added to classes as well.
|
code » | ||||
|
getAriaRole()
⇒
goog.dom.a11y.Role | undefined
Returns the ARIA role to be applied to the control.
See http://wiki/Main/ARIA for more info.
Returns:
goog.dom.a11y.Role | undefined
ARIA role.
|
code » | ||||
|
getClassForState(state)
⇒
Takes a single goog.ui.Component.State, and returns the
corresponding CSS class name (null if none).
Arguments:
Returns:
CSS class representing the given state (undefined if none).
|
code » | ||||
|
Returns all CSS class names applicable to the given control, based on its
state. The return value is an array of strings containing
Arguments:
|
code » | ||||
|
Takes a bit mask of goog.ui.Component.States, and returns an array
of the appropriate class names representing the given state, suitable to be
applied to the root element of a component rendered using this renderer, or
null if no state-specific classes need to be applied. This default
implementation uses the renderer's getClassForState method to
generate each state-specific class.
|
code » | ||||
|
getContentElement(element)
⇒
Takes the control's root element and returns the parent element of the
control's contents. Since by default controls are rendered as a single
DIV, the default implementation returns the element itself. Subclasses
with more complex DOM structures must override this method as needed.
|
code » | ||||
|
getCssClass()
⇒
Returns the CSS class name to be applied to the root element of all
components rendered or decorated using this renderer. The class name
is expected to uniquely identify the renderer class, i.e. no two
renderer classes are expected to share the same CSS class name.
Returns:
Renderer-specific CSS class name.
|
code » | ||||
|
Returns an array of combinations of classes to apply combined class names for
in IE6 and below. See IE6_CLASS_COMBINATIONS for more detail. This
method doesn't reference IE6_CLASS_COMBINATIONS so that it can be
compiled out, but subclasses should return their IE6_CLASS_COMBINATIONS
static contasnt instead.
|
code » | ||||
|
getKeyEventTarget(control)
⇒
Returns the element within the component's DOM that should receive keyboard
focus (null if none). The default implementation returns the control's root
element.
Arguments:
Returns:
The key event target.
|
code » | ||||
|
getStateFromClass(className)
⇒
goog.ui.Component.State
Takes a single CSS class name which may represent a component state, and
returns the corresponding component state (0x00 if none).
Arguments:
Returns:
goog.ui.Component.State
state Component state corresponding to the given CSS class (0x00 if none).
|
code » | ||||
|
getStructuralCssClass()
⇒
Returns the name of a DOM structure-specific CSS class to be applied to the
root element of all components rendered or decorated using this renderer.
Unlike the class name returned by #getCssClass, the structural class
name may be shared among different renderers that generate similar DOM
structures. The structural class name also serves as the basis of derived
class names used to identify and style structural elements of the control's
DOM, as well as the basis for state-specific class names. The default
implementation returns the same class name as #getCssClass, but
subclasses are expected to override this method as needed.
Returns:
DOM structure-specific CSS class name (same as the renderer- specific CSS class name by default).
|
code » | ||||
|
initializeDom(control)
Initializes the control's DOM by configuring properties that can only be set
after the DOM has entered the document. This implementation sets up BiDi
and keyboard focus. Called from goog.ui.Control#enterDocument.
Arguments:
|
code » | ||||
|
isFocusable(control)
⇒
Returns true if the control's key event target supports keyboard focus
(based on its
tabIndex attribute), false otherwise.
Arguments:
Returns:
Whether the control's key event target is focusable.
|
code » | ||||
|
setAllowTextSelection(element, allow)
Allows or disallows text selection within the control's DOM.
|
code » | ||||
|
setAriaRole(element)
Sets the element's ARIA role on browsers that support it.
Arguments:
|
code » | ||||
|
setContent(element, content)
Takes a control's root element, and sets its content to the given text
caption or DOM structure. The default implementation replaces the children
of the given element. Renderers that create more complex DOM structures
must override this method accordingly.
Arguments:
|
code » | ||||
|
setFocusable(control, focusable)
Updates the control's key event target to make it focusable or non-focusable
via its
tabIndex attribute. Does nothing if the control doesn't
support the FOCUSED state, or if it has no key event target.
Arguments:
|
code » | ||||
|
setRightToLeft(element, rightToLeft)
Applies special styling to/from the control's element if it is rendered
right-to-left, and removes it if it is rendered left-to-right.
|
code » | ||||
|
setState(control, state, enable)
Updates the appearance of the control in response to a state change.
Arguments:
|
code » | ||||
|
setVisible(element, visible)
Shows or hides the element.
|
code » | ||||
|
updateAriaState(element, state, enable)
Updates the element's ARIA (accessibility) state on Gecko.
|
code » |


Tried updating route with no current route
Occurs when an attempt is made to update the parameters on the current route when
there is no current route. This can happen if you try to call $route.updateParams();
before the first route transition has completed.