sglib.h
provides generic implementation of most
common algorithms for arrays, lists, sorted lists and red-black trees.
Implementation of double linked lists and hashed tables is envisaged.
Also suggestions for new useful functionalities are welcomed.
The library is generic and it does not define its own data
structures. Rather it acts on existing user defined data structures
via a generic interface. It also does not allocate or deallocate any
memory and does not depend on any particular memory management. In
case od several datatypes, sglib even does not impose its own data
representation. For example, sglib list routines can be applied to any
user defined structure containing a pointer to the same
structure as its field.
All algorithms are implemented in form of macros parametrized by the type of data structure and comparator function (or comparator macro). Several further generic parameters such as the name of 'next' field for linked lists may be required for some algorithms and data structures.
Sglib offers access to algorithms in two level user interface. A level - 0 interface is simply a collection of useful macros. If you do not like large macros or you afraid introduction of symbol clashes after macro expansions you can use a level - 1 interface. This interface generates legal C functions for each particular type. Those functions can be called from the main program without worrying about unwanted effects due to macro expansions.
You can always use level - 0 interface. You can use level - 1 interface only if your base type is named by a single identifier, or if you have defined a typedef for it.  It seems that you get the most advantages by using both interfaces in the same time. You can do this without worrying about implementation clashes, the level - 1 inplementation are just wrappers to level - 0 interface. However, few functions using recursion (red-black trees for example) are implemented exclusively in level - 1 interface.
During the design and implementation of sglib we have followed following rules:
#define SGLIB_NUMERIC_COMPARATOR(x, y) ((int)((x) - (y)))is a comparator for integers numbers. By the way, the macro
SGLIB_NUMERIC_COMPARATOR
with this definition
is predefined in sglib
and you can use it withount need of your own redefinitions.
cmp
is a comparator and subcmp
is its subcomparator, then:
cmp(x,y) < 0
implies subcmp(x,y) <= 0
cmp(x,y) > 0
implies subcmp(x,y) >= 0
#define strsubcmp(x, y) (x[0] - y[0])Using this subcomparator we can iterate over all strings starting with the same letter.
#define SGLIB_ARRAY_ELEMENTS_EXCHANGER(type, a, i, j) {type tmp;tmp=a[i];a[i]=a[j];a[j]=tmp;}is an elem_exchanger usable by sglib. By the way, the macro
SGLIB_ARRAY_ELEMENTS_EXCHANGER
with this definition
is predefined in the sglib and you can use in implementations of your own
elem_exchangers.
An elem_exchanger can be used to parametrize sorting
algorithms. The motivation is that
in many projects, several arrays keep related informations.
Elemens of different arrays having the same index are related to each other
and they form a single record. For example, one can represent a phone annuary by
keeping person names in one array (say name) and corresponding phone
numbers in another array (say phoneNumbers). In this representation the person
name[i]
has the phone number phoneNumber[i]
.

Sglib modifies arrays exclusively by using an elem_exchanger. You can use your own elem_exchanger as parameter for sorting algorithms. Your implementation can simultaneously exchange elements in several arrays, and hence make sorting to act on multiple related arrays. For example, continuing the annuary example, we can define the following elem_exchanger:
#define ANNUARY_EXCHANGER(type, a, i, j) { SGLIB_ARRAY_ELEMENTS_EXCHANGER(char *, name, i, j); SGLIB_ARRAY_ELEMENTS_EXCHANGER(int, phoneNumber, i, j);}and use it as parameter of a sorting macro. For example we can sort the first 1000 elements of the annuary by the following command:
SGLIB_ARRAY_QUICK_SORT(char*, name, 1000, strcmp, ANNUARY_EXCHANGER);
struct myintlist { int value; struct myintlist *next; }; struct history { int order; struct historyelem *h; // ... any other records struct history *previous; }; // you can even consider special trees as linked lists struct mytreenode { int nodetype; union nodeinformations node; struct mytrenode **subtrees; }; |
next
, previous
and subtrees[1]
.
The difference between pointer and comparator equality remains the
difference between ==
and equals
operators in Java language (with
the difference that in sglib user has to implement its own comparator).
E
is a pointer equal member of a container if it is physically
part of the data structure, i.e. if the container contains the pointer to E
.
We say that an element E
is a comparator equal member, if the container contains
an element which is comparator equal to E
.
In other words, an element is a comparator equal member of a container
if the container contains an element with the same key. Note that if an element
is a pointer equal member then it is also a comparator equal member.
struct mydoublelinkedlist { int value; struct mydoublelinkedlist *previous, *next; }; struct history { int order; struct historyelem *h; // ... any other records struct history *up, *down; }; |
previous
and next
. For the second structure
those parameters will be up
and down
.
struct myTreeNode { int key; struct myTreeNode *left; struct myTreeNode *right; }; struct generalTree { struct nodeInfo onfo; struct generalTree **subtrees; }; // you can have a structure which is a tree and a list at the same time struct listAndTree { int key; struct listAndTree *left_ptr; struct listAndTree *right_ptr; struct listAndTree *next_ptr; }; |
left, right
then subtrees[0], subtrees[1]
and finally
left_ptr, right_ptr
.
struct myTreeNode { int key; char color; struct myTreeNode *left; struct myTreeNode *right; }; struct TreeWithOneColorBit { struct { unsigned key:31; unsigned blackLabel:1; } bits; struct TreeWithOneColorBit *left; struct TreeWithOneColorBit *right; }; |
color
and bits.blackLabel
.
By convention, names of all macros start by SGLIB_ prefix. Then goes the identification of the data structure on which the macro operates and finaly the action performed by the macro.
In the design of macros we tried to make macros as generic as
possible. This sometimes leads to parameters which may seems useless.
However, because macro expansion is done in compile time and the
number of macro parameters does not affect the efficiency of the code,
we thing that additional parameters do not matter.
SGLIB_ARRAY_SINGLE_QUICK_SORT
| macro |
SGLIB_ARRAY_SINGLE_QUICK_SORT(type, a, max, comparator)
sort a single array using quicksort.
|
SGLIB_ARRAY_SINGLE_HEAP_SORT
| macro |
SGLIB_ARRAY_SINGLE_HEAP_SORT(type, a, max, comparator)
sort a single array using heapsort.
|
SGLIB_ARRAY_QUICK_SORT
| macro |
SGLIB_ARRAY_QUICK_SORT(type, a, max, comparator, elem_exchanger)
sort possibly multiple arrays using quicksort.
|
SGLIB_ARRAY_HEAP_SORT
| macro |
SGLIB_ARRAY_HEAP_SORT(type, a, max, comparator, elem_exchanger)
sort possibly multiple arrays using heapsort.
|
SGLIB_ARRAY_BINARY_SEARCH
| macro |
SGLIB_ARRAY_BINARY_SEARCH(type, a, start_index, end_index, key, comparator, found, result_index)
find the key in a sorted array using binary search.
|
SGLIB_LIST_ADD
| macro |
SGLIB_LIST_ADD(type, list, elem, next)
add an element to a list.
|
SGLIB_LIST_ADD_IF_NOT_MEMBER
| macro |
SGLIB_LIST_ADD_IF_NOT_MEMBER(type, list, elem, comparator, next, member)
add an element to a list if there is no comparator equal element inside.
|
SGLIB_LIST_CONCAT
| macro |
SGLIB_LIST_CONCAT(type, first, second, next)
concatenate two lists by appending the second at the end of the first.
|
SGLIB_LIST_DELETE
| macro |
SGLIB_LIST_DELETE(type, list, elem, next)
delete an element from a list. The element must be a pointer equal member of the list.
|
SGLIB_LIST_DELETE_IF_MEMBER
| macro |
SGLIB_LIST_DELETE_IF_MEMBER(type, list, elem, comparator, next, member)
remove a comparator equal element from a list.
|
SGLIB_LIST_IS_MEMBER
| macro |
SGLIB_LIST_IS_MEMBER(type, list, elem, next, result)
determine whether an element is a pointer member of a list.
|
SGLIB_LIST_FIND_MEMBER
| macro |
SGLIB_LIST_FIND_MEMBER(type, list, elem, comparator, next, result)
determine whether there is a comparator equal element in a list.
|
SGLIB_LIST_LEN
| macro |
SGLIB_LIST_LEN(type, list, next, result)
compute the length of a list.
|
SGLIB_LIST_MAP_ON_ELEMENTS
| macro |
SGLIB_LIST_MAP_ON_ELEMENTS(type, list, var, next, command)
apply a command on all elements of a list.
|
SGLIB_LIST_REVERSE
| macro |
SGLIB_LIST_REVERSE(type, list, next)
reverse a list.
|
SGLIB_LIST_SORT
| macro |
SGLIB_LIST_SORT(type, list, comparator, next)
sort a list using mergesort.
|
SGLIB_SORTED_LIST_ADD
| macro |
SGLIB_SORTED_LIST_ADD(type, list, elem, comparator, next)
insert an element into a sorted list.
|
SGLIB_SORTED_LIST_ADD_IF_NOT_MEMBER
| macro |
SGLIB_SORTED_LIST_ADD_IF_NOT_MEMBER(type, list, elem, comparator, next, member)
insert an element into a sorted list if there is no comparator equal element inside.
|
SGLIB_SORTED_LIST_DELETE
| macro |
SGLIB_SORTED_LIST_DELETE(type, list, elem, next)
delete an element from a sorted list. The element must be a pointer equal member of the list.
|
SGLIB_SORTED_LIST_DELETE_IF_MEMBER
| macro |
SGLIB_SORTED_LIST_DELETE_IF_MEMBER(type, list, elem, comparator, next, member)
remove a comparator equal element from a sorted list.
|
SGLIB_SORTED_LIST_IS_MEMBER
| macro |
SGLIB_SORTED_LIST_IS_MEMBER(type, list, elem, comparator, next, result)
determine whether an element is a pointer member of a sorted list.
|
SGLIB_SORTED_LIST_FIND_MEMBER
| macro |
SGLIB_SORTED_LIST_FIND_MEMBER(type, list, elem, comparator, next, result)
determine whether an element is a comparator member of a sorted list.
|
SGLIB_SORTED_LIST_FIND_MEMBER_OR_PLACE
| macro |
SGLIB_SORTED_LIST_FIND_MEMBER_OR_PLACE(type, list, elem, comparator, next, comparator_result, member_ptr)
determine whether an element is a comparator member of a sorted list, if not, find the place where to insert it.
|
SGLIB_SORTED_LIST_LEN
| macro |
SGLIB_SORTED_LIST_LEN(type, list, next, result)
compute the length of a list.
|
SGLIB_SORTED_LIST_MAP_ON_ELEMENTS
| macro |
SGLIB_SORTED_LIST_MAP_ON_ELEMENTS(type, list, var, next, command)
apply a command on all elements of a list.
|
SGLIB_DL_LIST_ADD
| macro |
SGLIB_DL_LIST_ADD(type, list, elem, previous, next)
add an element to a list. |
SGLIB_DL_LIST_ADD_BEFORE
| macro |
SGLIB_DL_LIST_ADD_BEFORE(type, list, elem, previous, next)
add an element to a list. Elem will be inserted before the element pointed by list .
|
SGLIB_DL_LIST_ADD_AFTER
| macro |
SGLIB_DL_LIST_ADD_AFTER(type, list, elem, previous, next)
add an element to a list. Elem will be inserted after the element pointed by list .
|
SGLIB_DL_LIST_ADD_IF_NOT_MEMBER
| macro |
SGLIB_DL_LIST_ADD_IF_NOT_MEMBER(type, list, elem, comparator, previous, next, member)
add an element to a list if there is no comparator equal element inside.
|
SGLIB_DL_LIST_ADD_BEFORE_IF_NOT_MEMBER
| macro |
SGLIB_DL_LIST_ADD_BEFORE_IF_NOT_MEMBER(type, list, elem, comparator, previous, next, member)
add an element to a list if there is no comparator equal element inside. Elem will be inserted before the element pointed by list .
|
SGLIB_DL_LIST_ADD_AFTER_IF_NOT_MEMBER
| macro |
SGLIB_DL_LIST_ADD_AFTER_IF_NOT_MEMBER(type, list, elem, comparator, previous, next, member)
add an element to a list if there is no comparator equal element inside. Elem will be inserted after the element pointed by list .
|
SGLIB_DL_LIST_CONCAT
| macro |
SGLIB_DL_LIST_CONCAT(type, first, second, previous, next)
concatenate two lists by appending the second at the end of the first. |
SGLIB_DL_LIST_DELETE
| macro |
SGLIB_DL_LIST_DELETE(type, list, elem, previous, next)
delete an element from a list. The element must be a pointer equal member of the list. |
SGLIB_DL_LIST_DELETE_IF_MEMBER
| macro |
SGLIB_DL_LIST_DELETE_IF_MEMBER(type, list, elem, comparator, previous, next, member)
remove a comparator equal element from a list.
|
SGLIB_DL_LIST_IS_MEMBER
| macro |
SGLIB_DL_LIST_IS_MEMBER(type, list, elem, previous, next, result)
determine whether an element is a pointer member of a list.
|
SGLIB_DL_LIST_FIND_MEMBER
| macro |
SGLIB_DL_LIST_FIND_MEMBER(type, list, elem, comparator, previous, next, result)
determine whether there is a comparator equal element in a list.
|
SGLIB_DL_LIST_GET_FIRST
| macro |
SGLIB_DL_LIST_GET_FIRST(type, list, previous, next, result)
get the first element of a list. |
SGLIB_DL_LIST_GET_LAST
| macro |
SGLIB_DL_LIST_GET_LAST(type, list, previous, next, result)
get the last element of a list. |
SGLIB_DL_LIST_LEN
| macro |
SGLIB_DL_LIST_LEN(type, list, previous, next, result)
compute the length of a list. |
SGLIB_DL_LIST_MAP_ON_ELEMENTS
| macro |
SGLIB_DL_LIST_MAP_ON_ELEMENTS(type, list, var, previous, next, command)
apply a command on all elements of a list. Command will be repeatedly executed for each element of the list accessible via the previous field and then via the next field. The current element of the list is stored in the
variable var .
|
SGLIB_DL_LIST_REVERSE
| macro |
SGLIB_DL_LIST_REVERSE(type, list, previous, next)
reverse a list. |
SGLIB_DL_LIST_SORT
| macro |
SGLIB_DL_LIST_SORT(type, list, comparator, previous, next)
sort a list using mergesort. As a side effect the list is set to the first element of the list.
|
SGLIB_BIN_TREE_MAP_ON_ELEMENTS
| macro |
SGLIB_BIN_TREE_MAP_ON_ELEMENTS(type, tree, var, left, right, command)
traverse a binary tree and apply command on each element. This is non-recursive implementation of tree traversal. It maintains the path to the current node in the array _path_ , the _path_[0] contains the root of the tree. The _path_[_pathi_-1] contains the parent of the var . The maximal deep of the tree is limited by SGLIB_MAX_TREE_DEEP macro.
|
Functions generated by above macros:
|
sglib_type_array_quick_sort
| function |
sglib_type_array_quick_sort(type *a, int max)
sort an array using quicksort.
|
sglib_type_array_heap_sort
| function |
sglib_type_array_heap_sort(type *a, int max)
sort an array using heapsort.
|
Hashed containers are provided only in level-1 interface because they
require a uniform interface for operations applied on the base container.
Functions generated by above macros:
|
sglib_hashed_type_init
| function |
void sglib_hashed_type_init(type *table[dim])
set each cell in the table to NULL.
|
sglib_hashed_type_add
| function |
void sglib_hashed_type_add(type *table[dim], type *elem)
Add an element into the hashed container.
|
sglib_hashed_type_add_if_not_member
| function |
int sglib_hashed_type_add_if_not_member(type *table[dim], type *elem, type **member)
Add an element into the hashed container if there is no comparator equal element inside.
|
sglib_hashed_type_delete
| function |
void sglib_hashed_type_delete(type *table[dim], type *elem)
delete an element from a hashed container. The element must be a pointer equal member of the hashed container.
|
sglib_hashed_type_delete_if_member
| function |
int sglib_hashed_type_delete_if_member(type *table[dim], type *elem, type **member)
find a comparator equal element in the hashed container and remove it.
|
sglib_hashed_type_is_member
| function |
int sglib_hashed_type_is_member(type *table[dim], type *elem)
determine whether an element is inside a hashed container. The element is searched using pointer equality.
|
sglib_hashed_type_find_member
| function |
type *sglib_hashed_type_find_member(type *table[dim], type *elem)
find an element in the hashed container. The element is searched using comparator equality.
|
sglib_hashed_type_it_init
| function |
type *sglib_hashed_type_it_init(struct sglib_type_iterator *it, type *table[dim])
initialize an iterator it to run over elements of table .
|
sglib_hashed_type_it_init_on_equal
| function |
type *sglib_hashed_type_it_init_on_equal(struct sglib_type_iterator *it, type *table[dim], int (*subcomparator)(type *, type *), type *equalto)
initialize an iterator it to run over those elements of table which are
equal to equalto . The equality is considered with respect to the
subcomparator which must be a subcomparator
of the base container comparator.
|
sglib_hashed_type_it_next
| function |
type *sglib_hashed_type_it_next(struct sglib_type_iterator *it)
get the next element from the iterator it .
|
Functions generated by above macros:
|
sglib_type_add
| function |
void sglib_type_add(type **list, type *elem)
insert an element into a list.
|
sglib_type_add_if_not_member
| function |
int sglib_type_add_if_not_member(type **list, type *elem, type **member)
insert an element if there is no comparator equal element in the list.
|
sglib_type_concat
| function |
void sglib_type_concat(type **first, type *second)
concatenate two lists by appending second at the end of the first.
|
sglib_type_delete
| function |
void sglib_type_delete(type **list, type *elem)
delete an element. The element must be a member of the list, it is looked using the pointer equality, not equality generated by comparator.
|
sglib_type_delete_if_member
| function |
int sglib_type_delete_if_member(type **list, type *elem, type **result)
find a comparator equal element in the list and remove it.
|
sglib_type_is_member
| function |
int sglib_type_is_member(type *list, type *elem)
determine whether an element is inside a list. The element is searched using pointer equality.
|
sglib_type_find_member
| function |
type *sglib_type_find_member(type **list, type *elem)
find an element in the list. The element is searched using comparator equality.
|
sglib_type_len
| function |
int sglib_type_len(type *list)
compute the length of a list.
|
sglib_type_sort
| function |
void sglib_type_sort(type **list)
sort the list according to comparator.
|
sglib_type_reverse
| function |
void sglib_type_reverse(type **list)
reverse the list.
|
sglib_type_it_init
| function |
type *sglib_type_it_init(struct sglib_type_iterator *it, type *list)
initialize an iterator it to run over elements of list .
|
sglib_type_it_init_on_equal
| function |
type *sglib_type_it_init_on_equal(struct sglib_type_iterator *it, type *list, int (*subcomparator)(type *, type *), type *equalto)
initialize an iterator it to run over those elements of list which are
equal to equalto . The equality is considered with respect to the
subcomparator which must be a subcomparator
of the comparator.
|
sglib_type_it_next
| function |
type *sglib_type_it_next(struct sglib_type_iterator *it)
get the next element from the iterator it .
|
Functions generated by above macros:
|
sglib_type_add
| function |
void sglib_type_add(type **list, type *elem)
insert an element into a list.
|
sglib_type_add_if_not_member
| function |
int sglib_type_add_if_not_member(type **list, type *elem, type **member)
insert an element if there is no comparator equal element in the list.
|
sglib_type_delete
| function |
void sglib_type_delete(type **list, type *elem)
delete an element. The element must be a member of the list, it is looked using the pointer equality, not equality generated by comparator.
|
sglib_type_delete_if_member
| function |
int sglib_type_delete_if_member(type **list, type *elem, type **result)
find a comparator equal element in the list and remove it.
|
sglib_type_is_member
| function |
int sglib_type_is_member(type *list, type *elem)
determine whether an element is inside a list. The element is searched using pointer equality.
|
sglib_type_find_member
| function |
type *sglib_type_find_member(type **list, type *elem)
find an element in the list. The element is searched using comparator equality.
|
sglib_type_len
| function |
int sglib_type_len(type *list)
compute the length of a list.
|
sglib_type_sort
| function |
void sglib_type_sort(type **list)
sort the list according to comparator. This function does not logically belong to this datatype as it is supposed that lists are kept sorted. However, it can be used to initial sorting, when the list was created by other than sglib functions.
|
sglib_type_it_init
| function |
type *sglib_type_it_init(struct sglib_type_iterator *it, type *list)
initialize an iterator it to run over elements of list .
|
sglib_type_it_init_on_equal
| function |
type *sglib_type_it_init_on_equal(struct sglib_type_iterator *it, type *list, int (*subcomparator)(type *, type *), type *equalto)
initialize an iterator it to run over those elements of list which are
equal to equalto . The equality is considered with respect to the
subcomparator which must be a subcomparator
of the comparator.
|
sglib_type_it_next
| function |
type *sglib_type_it_next(struct sglib_type_iterator *it)
get the next element from the iterator it .
|
Functions generated by above macros:
|
sglib_type_add
| function |
void sglib_type_add(type **list, type *elem)
insert an element into a list.
|
sglib_type_add_before
| function |
void sglib_type_add_before(type **list, type *elem)
insert an element into a list. Elem will be inserted before the element pointed by *list .
|
sglib_type_add_after
| function |
void sglib_type_add_after(type **list, type *elem)
insert an element into a list. Elem will be inserted after the element pointed by *list .
|
sglib_type_add_if_not_member
| function |
int sglib_type_add_if_not_member(type **list, type *elem, type **member)
insert an element if there is no comparator equal element in the list.
|
sglib_type_add_before_if_not_member
| function |
int sglib_type_add_before_if_not_member(type **list, type *elem)
insert an element if there is no comparator equal element in the list. Elem will be inserted before the element pointed by *list .
|
sglib_type_add_after_if_not_member
| function |
int sglib_type_add_after_if_not_member(type **list, type *elem)
insert an element if there is no comparator equal element in the list. Elem will be inserted before the element pointed by *list .
|
sglib_type_concat
| function |
void sglib_type_concat(type **first, type *second)
concatenate two lists by appending second at the end of the first.
|
sglib_type_delete
| function |
void sglib_type_delete(type **list, type *elem)
delete an element. The element must be a pointer equal member of the list.
|
sglib_type_delete_if_member
| function |
int sglib_type_delete_if_member(type **list, type *elem, type **result)
find a comparator equal element in the list and remove it.
|
sglib_type_is_member
| function |
int sglib_type_is_member(type *list, type *elem)
determine whether an element is inside a list. The element is searched using pointer equality.
|
sglib_type_find_member
| function |
type *sglib_type_find_member(type **list, type *elem)
find an element in the list. The element is searched using comparator equality.
|
sglib_type_get_first
| function |
type *sglib_type_get_first(type *list)
get the first element of a list.
|
sglib_type_get_last
| function |
type *sglib_type_get_last(type *list)
get the last element of a list.
|
sglib_type_len
| function |
int sglib_type_len(type *list)
compute the length of a list.
|
sglib_type_sort
| function |
void sglib_type_sort(type **list)
sort the list according to comparator. After the sorting *list will point to the first element of the list.
|
sglib_type_reverse
| function |
void sglib_type_reverse(type **list)
reverse the list.
|
sglib_type_it_init
| function |
type *sglib_type_it_init(struct sglib_type_iterator *it, type *list)
initialize an iterator it to run over elements of list .
|
sglib_type_it_init_on_equal
| function |
type *sglib_type_it_init_on_equal(struct sglib_type_iterator *it, type *list, int (*subcomparator)(type *, type *), type *equalto)
initialize an iterator it to run over those elements of list which are
equal to equalto . The equality is considered with respect to the
subcomparator which must be a subcomparator
of the comparator.
|
sglib_type_it_next
| function |
type *sglib_type_it_next(struct sglib_type_iterator *it)
get the next element from the iterator it .
|
Functions generated by above macros:
|
sglib_type_add
| function |
void sglib_type_add(type **tree, type *elem)
insert an element into a tree.
|
sglib_type_add_if_not_member
| function |
int sglib_type_add_if_not_member(type **tree, type *elem, type **member)
insert an element if there is no comparator equal element in the tree.
|
sglib_type_delete
| function |
void sglib_type_delete(type **tree, type *elem)
delete an element. The element must be a member of the tree, it is looked using the pointer equality, not equality generated by comparator.
|
sglib_type_delete_if_member
| function |
int sglib_type_delete_if_member(type **tree, type *elem, type **result)
find a comparator equal element in the tree and remove it.
|
sglib_type_is_member
| function |
int sglib_type_is_member(type *tree, type *elem)
determine whether an element is inside a tree. The element is searched using pointer equality.
|
sglib_type_find_member
| function |
type *sglib_type_find_member(type **tree, type *elem)
find an element in the tree. The element is searched using comparator equality.
|
sglib_type_len
| function |
int sglib_type_len(type *tree)
compute the length of a tree, i.e. compute how many elements is inside.
|
sglib_type_it_init
| function |
type *sglib_type_it_init(struct sglib_type_iterator *it, type *tree)
initialize an iterator it to run over elements of tree .
|
sglib_type_it_init_on_equal
| function |
type *sglib_type_it_init_on_equal(struct sglib_type_iterator *it, type *tree, int (*subcomparator)(type *, type *), type *equalto)
initialize an iterator it to run over those elements of the tree which are
equal to equalto . The equality is considered with respect to the
subcomparator which must be a subcomparator
of the comparator.
|
sglib_type_it_next
| function |
type *sglib_type_it_next(struct sglib_type_iterator *it)
get the next element from the iterator it .
|
// This program sorts its parameters using // array sort level 0 interface. // For example: // a.out 6 7 3 4 1 5 // writes // 1 3 4 5 6 7 #include <stdio.h> #include <stdlib.h> #include "sglib.h" #define MAX_ELEMS 1000 int main(int argc, char **argv) { int i,size; int a[MAX_ELEMS]; size = argc-1; for (i=0; i<size; i++) { sscanf(argv[i+1],"%d", &a[i]); } SGLIB_ARRAY_SINGLE_QUICK_SORT(int, a, size, SGLIB_NUMERIC_COMPARATOR); for (i=0; i<size; i++) { printf("%d ", a[i]); } printf("\n"); return(0); } |
// This program sorts its parameters using // array sort level 1 interface. // For example: // a.out 6 7 3 4 1 5 // writes // 1 3 4 5 6 7 #include <stdio.h> #include <stdlib.h> #include "sglib.h" #define MAX_ELEMS 1000 SGLIB_DEFINE_ARRAY_SORTING_FUNCTIONS(int, SGLIB_NUMERIC_COMPARATOR) int main(int argc, char **argv) { int i,size; int a[MAX_ELEMS]; size = argc-1; for (i=0; i<size; i++) { sscanf(argv[i+1],"%d", &a[i]); } sglib_int_array_heap_sort(a, size); for (i=0; i<size; i++) { printf("%d ", a[i]); } printf("\n"); return(0); } |
// This program sorts its parameters using // binary search to implement insert sort. // For example: // a.out 6 7 3 4 1 5 // writes // 1 3 4 5 6 7 #include <stdio.h> #include <stdlib.h> #include <string.h> #include "sglib.h" #define MAX_ELEMS 1000 int main(int argc, char **argv) { int i, size, found, index, tmp; int a[MAX_ELEMS]; size = argc-1; for (i=0; i<size; i++) { sscanf(argv[i+1],"%d", &a[i]); } for(i=1; i<size; i++) { tmp = a[i]; SGLIB_ARRAY_BINARY_SEARCH(int, a, 0, i, tmp, SGLIB_NUMERIC_COMPARATOR, found, index); memmove(a+index+1, a+index, (i-index)*sizeof(int)); a[index]=tmp; } for (i=0; i<size; i++) { printf("%d ", a[i]); } printf("\n"); return(0); } |
// This program sorts its parameters using // list sort (level 0 interface). // For example: // a.out 6 7 3 4 1 5 // writes // 1 3 4 5 6 7 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include "sglib.h" struct ilist { int i; struct ilist *next_ptr; }; #define ILIST_COMPARATOR(e1, e2) (e1->i - e2->i) int main(int argc, char **argv) { int i,a; struct ilist *l, *the_list, *ll; the_list = NULL; for (i=1; i<argc; i++) { sscanf(argv[i],"%d", &a); l = malloc(sizeof(struct ilist)); l->i = a; SGLIB_LIST_ADD(struct ilist, the_list, l, next_ptr); } // it is useless, but anyway, get parameters in the right order SGLIB_LIST_REVERSE(struct ilist, the_list, next_ptr); // now sort them SGLIB_LIST_SORT(struct ilist, the_list, ILIST_COMPARATOR, next_ptr); // print the list SGLIB_LIST_MAP_ON_ELEMENTS(struct ilist, the_list, ll, next_ptr, { printf("%d ", ll->i); }); printf("\n"); // free all SGLIB_LIST_MAP_ON_ELEMENTS(struct ilist, the_list, ll, next_ptr, { free(ll); }); return(0); } |
// This program sorts its parameters using // insertion into sorted list (level 0 interface). // For example: // a.out 6 7 3 4 1 5 // writes // 1 3 4 5 6 7 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include "sglib.h" struct ilist { int i; struct ilist *next_ptr; }; #define ILIST_COMPARATOR(e1, e2) (e1->i - e2->i) int main(int argc, char **argv) { int i,a; struct ilist *l, *the_list, *ll; the_list = NULL; for (i=1; i<argc; i++) { sscanf(argv[i],"%d", &a); l = malloc(sizeof(struct ilist)); l->i = a; // insert the new element into the list while keeping it sorted SGLIB_SORTED_LIST_ADD(struct ilist, the_list, l, ILIST_COMPARATOR, next_ptr); } SGLIB_LIST_MAP_ON_ELEMENTS(struct ilist, the_list, ll, next_ptr, { printf("%d ", ll->i); }); printf("\n"); SGLIB_LIST_MAP_ON_ELEMENTS(struct ilist, the_list, ll, next_ptr, { free(ll); }); return(0); } |
// This program sorts its parameters using // insertion into sorted list (level 1 interface). // For example: // a.out 6 7 3 4 1 5 // writes // 1 3 4 5 6 7 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include "sglib.h" typedef struct ilist { int i; struct ilist *next_ptr; } iListType; #define ILIST_COMPARATOR(e1, e2) (e1->i - e2->i) SGLIB_DEFINE_SORTED_LIST_PROTOTYPES(iListType, ILIST_COMPARATOR, next_ptr) SGLIB_DEFINE_SORTED_LIST_FUNCTIONS(iListType, ILIST_COMPARATOR, next_ptr) int main(int argc, char **argv) { int i,a; struct ilist *l, *the_list; struct sglib_iListType_iterator it; the_list = NULL; for (i=1; i<argc; i++) { sscanf(argv[i],"%d", &a); l = malloc(sizeof(struct ilist)); l->i = a; // insert the new element into the list while keeping it sorted sglib_iListType_add(&the_list, l); } // print the list for (l=the_list; l!=NULL; l=l->next_ptr) { printf("%d ", l->i); } printf("\n"); // free all for(l=sglib_iListType_it_init(&it,the_list); l!=NULL; l=sglib_iListType_it_next(&it)) { free(l); } return(0); } |
// This program reads parameters, sorts them // and write them in both directions. // The program is using level 1 interface. // For example: // a.out 6 7 3 4 1 5 // writes // 1 3 4 5 6 7 // 7 6 5 4 3 1 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include "sglib.h" typedef struct dllist { int i; struct dllist *ptr_to_next; struct dllist *ptr_to_previous; } dllist; #define DLLIST_COMPARATOR(e1, e2) (e1->i - e2->i) SGLIB_DEFINE_DL_LIST_PROTOTYPES(dllist, DLLIST_COMPARATOR, ptr_to_previous, ptr_to_next); SGLIB_DEFINE_DL_LIST_FUNCTIONS(dllist, DLLIST_COMPARATOR, ptr_to_previous, ptr_to_next); int main(int argc, char **argv) { int i,a; dllist *l, *the_list; struct sglib_dllist_iterator it; the_list = NULL; for (i=1; i<argc; i++) { sscanf(argv[i],"%d", &a); l = malloc(sizeof(dllist)); l->i = a; sglib_dllist_add(&the_list, l); } // sort the list sglib_dllist_sort(&the_list); // print the list for(l=sglib_dllist_get_first(the_list); l!=NULL; l=l->ptr_to_next) printf("%d ", l->i); printf("\n"); // print the list in reversed direction for(l=sglib_dllist_get_last(the_list); l!=NULL; l=l->ptr_to_previous) printf("%d ", l->i); printf("\n"); // free the list for(l=sglib_dllist_it_init(&it,the_list); l!=NULL; l=sglib_dllist_it_next(&it)) { free(l); } return(0); } |
// This program uses hash table containing lists // to remove multiple occurences of its parameters // For example: // a.out 1 3 1 5 2 3 1 7 11 33 11 // writes: // 11 1 2 33 3 5 7 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include "sglib.h" #define HASH_TAB_SIZE 10 typedef struct ilist { int i; struct ilist *next; } ilist; ilist *htab[HASH_TAB_SIZE]; #define ILIST_COMPARATOR(e1, e2) (e1->i - e2->i) unsigned int ilist_hash_function(ilist *e) { return(e->i); } SGLIB_DEFINE_LIST_PROTOTYPES(ilist, ILIST_COMPARATOR, next) SGLIB_DEFINE_LIST_FUNCTIONS(ilist, ILIST_COMPARATOR, next) SGLIB_DEFINE_HASHED_CONTAINER_PROTOTYPES(ilist, HASH_TAB_SIZE, ilist_hash_function) SGLIB_DEFINE_HASHED_CONTAINER_FUNCTIONS(ilist, HASH_TAB_SIZE, ilist_hash_function) int main(int argc, char **argv) { int i, ai,aj, n; struct ilist ii, *nn, *ll; struct sglib_hashed_ilist_iterator it; sglib_hashed_ilist_init(htab); for (i=1; i<argc; i++) { sscanf(argv[i],"%d", &n); ii.i = n; if (sglib_hashed_ilist_find_member(htab, &ii) == NULL) { nn = malloc(sizeof(struct ilist)); nn->i = n; sglib_hashed_ilist_add(htab, nn); } } for(ll=sglib_hashed_ilist_it_init(&it,htab); ll!=NULL; ll=sglib_hashed_ilist_it_next(&it)) { printf("%d ", ll->i); } printf("\n"); for(ll=sglib_hashed_ilist_it_init(&it,htab); ll!=NULL; ll=sglib_hashed_ilist_it_next(&it)) { free(ll); } return(0); } |
// This program uses red-black tree to // remove multiple occurences of the same // value from its paramaters. // For example: // a.out 6 7 3 4 1 4 1 3 5 // writes: // 1 3 4 5 6 7 #include <stdio.h> #include <stdlib.h> #include "sglib.h" typedef struct rbtree { int n; char color_field; struct rbtree *left; struct rbtree *right; } rbtree; #define CMPARATOR(x,y) ((x->n)-(y->n)) SGLIB_DEFINE_RBTREE_PROTOTYPES(rbtree, left, right, color_field, CMPARATOR); SGLIB_DEFINE_RBTREE_FUNCTIONS(rbtree, left, right, color_field, CMPARATOR); int main(int argc, char **argv) { int i,a; struct rbtree e, *t, *the_tree, *te; struct sglib_rbtree_iterator it; the_tree = NULL; for (i=1; i<argc; i++) { sscanf(argv[i],"%d", &a); e.n = a; if (sglib_rbtree_find_member(the_tree, &e)==NULL) { t = malloc(sizeof(struct rbtree)); t->n = a; sglib_rbtree_add(&the_tree, t); } } for(te=sglib_rbtree_it_init_inorder(&it,the_tree); te!=NULL; te=sglib_rbtree_it_next(&it)) { printf("%d ", te->n); } printf("\n"); for(te=sglib_rbtree_it_init(&it,the_tree); te!=NULL; te=sglib_rbtree_it_next(&it)) { free(te); } return(0); } |


requestHandler Class
This is the main program that accepts client requests and call other functions.
Item Index
Methods
dataHandler
-
The
-
method
-
query
-
postData
Response handler to /data URI.
Parameters:
-
The
Objecthttp.server.response object of the request.
-
method
ObjectThe HTTP method (in all caps).
-
query
ObjectThe query string component of the URI
-
postData
ObjectThe post data (parsed into an Object).
decodeQuery
-
query
Decodes a query string in the form q=
Parameters:
-
query
ObjectA query string in the form q=
Returns:
metrics
-
response
-
method
-
query
-
postData
Response handler to /metrics URI.
Parameters:
-
response
ObjectThe http.server.response object of the request.
-
method
ObjectThe HTTP method (in all caps).
-
query
ObjectThe query string component of the URI
-
postData
ObjectThe post data (parsed into an Object). (should be empty for a metric request)
notFound
-
response
-
method
-
query
-
postData
Handles with 404 errors.
Parameters:
-
response
ObjectThe http.server.response object of the request.
-
method
ObjectThe HTTP method (in all caps).
-
query
ObjectThe query string component of the URI
-
postData
ObjectThe post data (parsed into an Object). (should be empty for a metric request)
validateObjID
-
a
TODO
Parameters:
-
a
Objectstring containing the object id to validate


By default, users who are not members of your organization can not find any of your APIs.
By changing the discoverability of this plan, you can selectively allow non-members to find and
subscribe to your plans.
By applying this change, your API would be visible to:
-
- Further configuration for the developer portal can be found in the Developer Portal tab.
This API will be visible to users outside your organization.


[the cutting edge ]
G'day Developers!
The SPARROW project for Brisbane Catholic Education: When Scrum fosters
collaboration
Figure: BCE SPARROW uses a 'metro' design with all the latest Nuget packages for
elegant, consistent and usable design
The benefits of continually improving our processes and practices around the Scrum
methodology were never more apparent than with the project we have recently completed
for Brisbane Catholic Education (BCE).
As developers, we’ve all worked on projects where the level of collaboration can break
down due to any number of factors such as scope creep, availability of the Product
Owner, ill-defined requirements or inadequate testing. One of the strongest benefits of
Scrum is the focus on communication and feedback to alleviate these symptoms.
The BCE SPARROW Project
The SPARROW project is an extranet site designed to assist school principals when
performing long term strategic planning for their school. As such, this was a project
with many stakeholders.
On arrival, we found that BCE were ready for Scrum. They had tried applying agile
principles to their own projects previously and were interested in formalizing the
process. Following Scrum helped us to build a single collaborative development team
comprising developers and a designer from SSW with testers and IT staff from BCE. The
SSW team for this project included
Damian
Brady, Adam
Stephensen,
Brendan
Richards, Ben
Cull
and Rebecca
Liu.
Client Role: The Product Owner
It was a pleasure to work with an excellent Product Owner from BCE, Kerry
Edwards-Williams. Kerry performed brilliantly at managing the diversity of stakeholder
input to give the develoment team a single source of truth for tasks on the Product
Backlog. For more information on this key role see What is a Product Owner.
"I would not undertake any other project without using the Scrum
methodology. I think it's absolutely exceptional. It's fantastic. I
think my favorite thing about working on the project, was learning about
the scrum methodology... and working with the SSW team... I'd highly
recommend them to anybody." - Kerry Edwards-Williams.
|
Client Role: The Tester
BCE Testers, led by Latha Matta, used Microsoft Test Manager to provide excellent bug
reports directly into TFS – as per our rule: Do
you know the three steps to a PBI?
Making client testers part of the development team worked to break down barriers between
client and vendor and fostered mutual understanding and respect. This, in turn, led to
fantastic turnaround times in identifying and responding to issues.
For Adam’s whole blog post including technical
details, keep
reading!
Of course, you can learn for yourself everything about how we build awesome web
applications at our FireBootCamp.
-Adam Cogan, SSW
Got a comment for Adam?
Email Adam Cogan
Comment
Adam Cogan's blog
Tweet @adamcogan
|
Become a World Class Developer in just 9 weeks with FireBootCamp!
Special Intensive Course
Sydney, Brisbane, Melbourne, San Francisco
Special introductory cost: $3,000 + GST
Regular cost: $6,000 + GST
FireBootCamp Sydney is only 1 week away! Become a world class .NET developer in 9 weeks
starting on the 20th January.
There are a few places left, so go to www.firebootcamp.com
to find out more
The FireBootCamp program is an intensive, full-time, 9-week program. Participants learn, work
and code together for 10-12 hours per day, 5 days
a week. There are exercise and food breaks, but for the main the program is continual
hands-on learning.
The program focuses on real world skills including agile software development practices,
enterprise architecture, application life cycle,
end-to-end testing and user interface design. The technology stack covers .NET MVC,
TypeScript, JavaScript & jQuery and uses Microsoft Visual Studio 2013.
Scheduled Boot Camps:
Sydney BootCamp #1
20th JAN 2014 – 21st MAR 2014 |
Brisbane BootCamp #1
7th APR 2014 – 6th JUN 2014
|
San Francisco BootCamp #1
23rd JUN 2014 – 22nd AUG 2014 |
Sydney BootCamp #2
23rd JUN 2014 – 22nd AUG 2014
|
Melbourne BootCamp #1
8th SEP 2014 – 7th NOV 2014
|
Find
out more and Register
|
Windows Phone 8 Development with Microsoft MVP Michael Crump
In this video, SSW TV’s Adam Stephensen is joined by Michael Crump, who dives into his
experiences developing for Windows Phone 8.
Michael is an MVP who works for our good friends at Telerik. He has written for MSDN, he is a
PluralSight author and he has spoken all over the world.
In this video, they discuss:
- The phones that Michael has in his arsenal
- Pain points developing for the Windows Phone platform
- Upgrading from Windows Phone 7 to Windows Phone 8
- Maps control in Windows Phone 8
- In app purchasing
- Speech and text recognition
- Experiences with app development
- Getting a Cease and Desist letter for developing a Twitter app
- Lessons learned developing for Windows Phone
- What the future holds for the platform
This is a great video for anyone who’s thinking about developing for the Windows Phone
platform.
Watch
more videos on SSW TV
|
There's Still Time to Sign Up for the 3 Day Scrum Training!
Intensive Professional Scrum Developer Course
|
|
Brisbane, Melbourne, Sydney, Perth, Canberra, Adelaide
Cost: $2,995 + GST
|
Professional Scrum Developer courses teach students how to work in a team - using modern software
engineering practices - to develop
an increment of potentially releasable functionality using a specific technology platform.
Classes are exercise-driven, with students working in self-organizing teams to develop "done"
increments from Product Backlog items.
Course at a Glance:
This 3-day Professional Scrum Developer .NET course is a mix of lecture, demonstration, group
discussion, simulation, and hands-on
software development. The bulk of the course will be spent working as a team on a case study
application delivering increments of new
functionality in mini-sprints. Here is the course at a glance:
Note: Scrum fundamentals are not covered in this 3-day course. If you are not experienced with Scrum
fundamentals, the
5
day course is still available.
Adelaide
04 FEB 2014 |
|
Perth
10 FEB 2014 |
|
Canberra
10 MAR 2014 |
|
Melbourne
7 APR 2014 |
|
Sydney
28 APR 2014 |
|
Find
out more and Register
|
Sydney .NET January User Group
The best place to learn .NET for free in Sydney
|
|
Sydney
.NET User Group
Wednesday 15th January 2014
6:00pm - 8:00pm
SSW Office
Gateway Court, Suite 13
81-91 Military Road, Neutral Bay NSW 2089
|
"Building highly scalable HTML5 web and mobile applications with Tribe" - Dale
Anderson
It is widely accepted in the industry that messaging patterns like CQRS can facilitate massively
scalable applications with loosely coupled components.
Tribe takes a different approach to current single page web application frameworks by providing a
full composite UI framework with a messaging platform
at its core. This enables the rapid development of highly scalable applications built on patterns
like CQRS in a simple and intuitive way. The platform also
enables seamless, real time distribution of objects on a large scale across multiple devices.
First, we'll briefly discuss some of the concepts behind messaging patterns like CQRS. Then we'll
build a simple chat application that targets both browsers
and mobile devices (hopefully using a preview of the upcoming nodejs based release), showcasing how
Tribe is focused around removing common pain points and
repetitive tasks in developing web applications. Finally we'll cover how the concepts discussed
earlier can be applied using the platform and have a quick
look at the product roadmap.
About the presenter:
Dale Anderson is an exceptionally passionate software engineer. He lives and breathes the stuff
every day and loves every moment.
Lucky to have been born in the age when Steve Jobs was busy changing the world, Dale fondly remembers
hacking on his dad's Apple
II Plus as a youngster, fervently and conscientiously transcribing code from the pages of computing
magazines and then excitedly watching
the green ASCII characters fly across the screen as the program came to life. Later, the idea of
networking computers together fascinated
him, driving his parents crazy by tying up the phone line for hours on end as the modem clicked and
buzzed away at a blazing 2,400 bits
every second. Dale was even nerdy enough to read the entire RFC specifications for the TCP/IP
protocols and various other incredibly
dry pieces of literature.
Dale has spent most of his 13+ year career focused on the Microsoft technology stack, working with a
wide range of government and corporate
clients, specialising in solution architecture. He has in depth knowledge of a broad range of
Microsoft technologies, covering web, desktop
and middleware stacks. Over the last few years, Dale founded a startup, SportingTribe, and in the
process, has become an expert in open source web
technologies. He has produced a number of open source projects in that domain (http://tribejs.com/ and
http://packscript.com/).
To see more details and RSVP, please visit
our Facebook .NET Group,
our LinkedIn
.NET Group
or our Meetup Group.
|
Can't make it to the Sydney .NET User Group?
Watch the Live stream!
|
|
Tune in from anywhere!
Sydney .NET User Group Live
6PM AEDT (UTC+11)
The team at SSWTV are now streaming our User Group sessions live. Each session will also
be published on the SSWTV site after the event so you can review what was said in the
sessions.
|
|
Then join us at the NerdDinner
Where nerds meet and eat
SSW and Telerik invite you to join us for pizza at The Oaks. A fantastic opportunity for networking
with peers and sharing thoughts after the Sydney .NET User Group presentation.
Sydney .Net User Group and NerdDinner proudly sponsored by:
|
Canberra .NET User Group
The best place to learn .NET for free in Canberra
|
|
Canberra
.NET User Group
Monday 13th January 2014
6:00pm - 8:00pm
Microsoft Canberra Branch
Level 4, 6 National Circuit
Barton, Australia
|
"Building highly scalable HTML5 web and mobile applications with Tribe" - Dale
Anderson
It is widely accepted in the industry that messaging patterns like CQRS can facilitate massively
scalable applications with loosely coupled components.
Tribe takes a different approach to current single page web application frameworks by providing a
full composite UI framework with a messaging platform
at its core. This enables the rapid development of highly scalable applications built on patterns
like CQRS in a simple and intuitive way. The platform also
enables seamless, real time distribution of objects on a large scale across multiple devices.
First, we'll briefly discuss some of the concepts behind messaging patterns like CQRS. Then we'll
build a simple chat application that targets both browsers
and mobile devices (hopefully using a preview of the upcoming nodejs based release), showcasing how
Tribe is focused around removing common pain points and
repetitive tasks in developing web applications. Finally we'll cover how the concepts discussed
earlier can be applied using the platform and have a quick
look at the product roadmap.
About the presenter:
Dale Anderson is an exceptionally passionate software engineer. He lives and breathes the stuff
every day and loves every moment.
Lucky to have been born in the age when Steve Jobs was busy changing the world, Dale fondly remembers
hacking on his dad's Apple
II Plus as a youngster, fervently and conscientiously transcribing code from the pages of computing
magazines and then excitedly watching
the green ASCII characters fly across the screen as the program came to life. Later, the idea of
networking computers together fascinated
him, driving his parents crazy by tying up the phone line for hours on end as the modem clicked and
buzzed away at a blazing 2,400 bits
every second. Dale was even nerdy enough to read the entire RFC specifications for the TCP/IP
protocols and various other incredibly
dry pieces of literature.
Dale has spent most of his 13+ year career focused on the Microsoft technology stack, working with a
wide range of government and corporate
clients, specialising in solution architecture. He has in depth knowledge of a broad range of
Microsoft technologies, covering web, desktop
and middleware stacks. Over the last few years, Dale founded a startup, SportingTribe, and in the
process, has become an expert in open source web
technologies. He has produced a number of open source projects in that domain (http://tribejs.com/ and
http://packscript.com/).
To see more details and RSVP, please visit
our Facebook .NET Group,
our LinkedIn
.NET Group or
our Meetup Group.
Canberra .Net User Group proudly sponsored by:
>
|
Advertise with SSW
If you would like to advertise your product or service with SSW or would like to
find out more about various advertising opportunities, please email your enquiry
to<EMAIL_ADDRESS>or call: +61 2 9953 3000.
|
|
January 2014
|
Employment
ASP.NET MVC, Software Developer
SSW is looking for an enthusiastic .NET MVC (and some ASP.NET Web Forms) developer. Our ideal
candidate will have strong skills designing and
implementing ASP.NET MVC and Web Forms applications using C#, a good understanding of XML,
HTML5, CSS3, JavaScript and a working knowledge of agile software
development methodologies (preferably Scrum).
Read
more and APPLY NOW...
SharePoint 2013 Developer
Are you looking to establish a career working with the latest software technology for a large
range of great organisations?
SSW has been the leading Microsoft technology company in Sydney for 21 years. We require an
enthusiastic SharePoint developer to start ASAP.
Read
more and APPLY NOW...
|
|


Instruction of account roles
Administrators have full permissions while editors not, editors cannot:
1. edit/remove customers and send auto-mails to them
2. set product category structures
3. view online user list
4. modify inventory information
5. manage accounts


Course Registration
Prefered Course
-- Choose --
Digital Project Management
Digital Product Management
Digital Business Analysis
Digital Performance Management
Digital Specialist
User Research
Data Analysis
Content & Design
Digital Leadership
Operation Management
Second Choice Course
-- Choose --
Digital Project Management
Digital Product Management
Digital Business Analysis
Digital Performance Management
Digital Specialist
User Research
Data Analysis
Content & Design
Digital Leadership
Operation Management
Price
#200, 000.00
#300, 000.00
#400, 000.00
#500, 000.00
#600, 000.00
#700, 000.00
#800, 000.00
#900, 000.00
#100, 000.00
#90, 000.00
Next
Back to homepage


Resume Submit
Requirement Submit
Requirement Management
Search
Sign Out
Date of Opening
Requirement ID
Client
Primary Skills
No Of Positions
Open positions
Minimum Exp
Location
BD POC
Status
Description
Note
{% for result in list %}
{%csrf_token%}
{{result.0}}
{{result.1}}
{{result.2}}
{{result.3}}
{{result.4}}
{{result.5}}
{{result.6}}
{{result.7}}
{{result.8}}
{{result.9}}
{{result.10}}
{{result.11}}
{% endfor %}


Brett Schiff |
|---|
|
Contact Info<EMAIL_ADDRESS>LinkedIn |
Back to Personal Projects |
|---|
JavaScript |
|
|---|---|
Conway's Game of Life |
|
|
Speed: |
Brett's Musical Dots |
|
|
This is inspired by the College Humor "Musical Dots" toy that is no longer working. Mine is less pretty, but has more features and a bigger space to work in. The actual sound here I recorded from my Kalimba(an instrument I "play") and edited in Audacity. |
|
|
Controls: The following options clear the board on use: |
Speed: Volume: |


Screen
Device width:
Device height:
Device pixel ratio:
Fonts
Helvetica
Lucida Grande
Verdana
Tahoma
Georgia
Times New Roman
Courier New
Missing fonts will be like this (monospace)


Books I Read
01 May 2015This is a list of books I’ve recently read or I am still reading. The “problem” I’m having is that I start reading more books at once instead of one by one, since I perform very badly in multitasking, but if something interests me I start it immediately.
Programming:
- Professional PHP Design Patterns - Aaron Saray
- Build APIs You Won’t Hate - Phil Sturgeon
- Practical Design Patterns in PHP - Brandon Savage
- The Book for Symfony 2.5
- Scaling PHP Applications - Steve Corona
- Securing PHP Web Applications - Tricia Ballad & William Ballad
- MongoDB The Definitive Guide - Kristina Chodorow & Michael Dirolf
- MySQL High Availability - Charles Bell, Mats Kindahl & Lars Thalmann
Non-programming:
- The War of Art - Steven Pressfield
- Team Geek A Software Developer’s Guide to Working Well with Others
- Freedom From The Know – Krishnamurti
- A Tree in A Forest – A Collection of Ajahn Chan’s Similes


Provide the defect list and the rectification tips for the inspection on customer installation for application of new or additional supply. The CSV file contains the defect details (including code, section, type and description) and the rectification tips.


ABC Flashcards
Hover over each card to reveal the answer!
Click each card to reveal the answer!


I am an MEng student in Computer Science at MIT, with an expected graduation date of June 2020.
Teaching
- 6.02 Intro to EECS via Digital Communications:
- Instructor-G: Fall ‘19 (current)
- 6.033 Computer Systems Engineering:
- Instructor-G: Spring ‘19
- 6.004 Computation Structures:
- Teaching Assistant: Fall ‘15, Spring ‘16, Fall ‘17, Spring ‘18, Fall ‘18
- Off-semester work: Summer ‘16, January ‘18, Summer ‘18
- Teaching Assistant (EdX): Spring ‘15
- Lab Assistant: Fall ‘14
- 6.S098 Introduction to R for Data Science:
- Instructor: January ‘18
Personal projects (mostly fun)
You can find most of my coding projects on Github @nibrivia.
- 6.004 queue metrics: A live web app to monitor the state of the help queue
- ATLAS: Automated reduction and analysis of exoplanet data
- Luminifu: A functional light display (LED strips, …) manager in Haskell
Professional work
I worked for a year as a Data Analyst Fellow at iCivics and continue to occasionally help out.
Personal
I grew up in Belgium, but my mother is from up the road in Cambridge, MA. My education up to MIT was done in the French system, where I got my BAC in the scientific section at French school in Brussels.
I particularly enjoy cooking, biking, and walks in the city.
Contact
Email is usually the best way to get in touch with me. You are welcome to text me as well, especially for personal or urgent concerns.


by Arthur RIGAUD
I discovered web accessibility 19 years ago
I am begining with automatic testing in NPM
You'll see results of demo
but no demo (My VPN is blocked)
Do you know NPM ?
Do you use automatic tools for accessibility audits?
Uses HTML Code Sniffer Engine
npm install pa11y --save-dev
To use it you can add in "scripts"
in your package.json file
"scripts": { "pa11y": "pa11y" }
pa11y <url>
pa11y --include-warnings <url>
pa11y --include-warnings <url> -R <elements you want to test>
pa11y --include-warnings <url> -E <elements you exclude>
pa11y --include-warnings <url> -E <elements you exclude>
Project by Google
included in Chrome
Uses Axe for accessibility
Documentation about Lighthouse on npm
npm install -g lighthouse
If installed globally you can use it directly in command line
lighthouse https://deque.com
Can also be runned on multiple urls
Project by BBC in the UK to test
their own accessibility standards
npm install bbc-a11y --save-dev
To use it you can add in "scripts" in your package.json file
"scripts": { "a11y": "bbc-a11y" }
Let's test it!
npm run a11y https://bbc.co.uk npm run a11y https://pa11y.org
While automatic testing tools are useful, testing with #disabled user testers, as we have always done, is extremely valuable and brings unique #a11y insights. Working in partnership with disabled people is productive and important.
— Robyn Hunt (@AccEase) 15 juillet 2018
"Automation can do a lot of grunt work for you – but in the end, you’re going to need to check your work." nailedhttps://t.co/KMkcfrpwh6
— Steve Faulkner (@stevefaulkner) 6 février 2017
"Automated accessibility tests aren’t a turnkey solution, nor are they a silver bullet. There are some limitations to keep in mind when using them." Another great article by @ericwbailey #a11y https://t.co/xeAvAHK9qY
— Manuel Matuzovi? (@mmatuzo) 13 septembre 2018
The Importance Of Manual Accessibility Testing: Automated #a11y tests are a great resource to have, but they can’t automatically make your site accessible. Use them as one step of a larger testing process. https://t.co/tuTZMKQUQf by @ericwbailey
— Deque Systems (@dequesystems) 13 septembre 2018


RAF Typhoons scrambled 'as drunk passenger tried to open door'
Two RAF fighter jets were scrambled to escort a packed Jet2 passenger flight back to Stansted, after a woman tried to open the door of the plane mid-flight.
Chloe Haines, 26, of High Wycombe, Buckinghamshire, is alleged to have been drunk when she assaulted a member of cabin crew who tried to restrain her during the incident on June 22.
The flight was travelling to Dalaman in Turkey, before the pilot was forced to return to Stansted.
Haines was given an £85,000 bill by Jet2, who also banned her for life from flying with the airline.
She appeared at Chelmsford Magistrates’ Court today, charged with one count of assault by beating and one count of recklessly or negligently acting in a manner likely to endanger an aircraft or person in an aircraft.
She was arrested by Essex Police upon landing.
On board the flight, a cabin crew member allegedly suffered scratches as she tried to prevent Haines from opening the plane door.
In court, Haines, with her hair worn up and wearing a black top, spoke only to confirm her name, date of birth, address and British nationality.
Advertisement Advertisement
She did not enter pleas during the 10-minute hearing.
District Judge Timothy King granted Haines conditional bail on the grounds that she does not travel from any UK airport.
He sent her case to Chelmsford Crown Court, where she is due to appear on December 18.
Got a story for Metro.co.uk?
Get in touch with our news team by emailing us at<EMAIL_ADDRESS>For more stories like this, check our news page.