[vala/wip/gee: 40/44] Update internal gee from libgee 0.8.8+d531caa9
- From: Rico Tzschichholz <ricotz src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [vala/wip/gee: 40/44] Update internal gee from libgee 0.8.8+d531caa9
- Date: Mon, 10 Oct 2016 20:25:19 +0000 (UTC)
commit 05a9da8d5f9335d4a04b6f673eaf96c57be33ea5
Author: Rico Tzschichholz <ricotz ubuntu com>
Date: Mon Aug 25 13:24:07 2014 +0200
Update internal gee from libgee 0.8.8+d531caa9
Based on patch by Maciej Piechotka
https://bugzilla.gnome.org/show_bug.cgi?id=704754
ccode/valaccodefile.vala | 4 +-
codegen/valaccodebasemodule.vala | 22 +-
codegen/valaccodedelegatemodule.vala | 8 +-
codegen/valaccodemethodcallmodule.vala | 8 +-
codegen/valaccodemethodmodule.vala | 22 +-
codegen/valagasyncmodule.vala | 36 +-
codegen/valagdbusclientmodule.vala | 8 +-
codegen/valagirwriter.vala | 18 +-
codegen/valagtkmodule.vala | 12 +-
codegen/valagtypemodule.vala | 6 +-
gee/Makefile.am | 54 +-
gee/abstractbidirlist.vala | 46 +
gee/abstractbidirsortedmap.vala | 53 +
gee/abstractbidirsortedset.vala | 53 +
gee/abstractcollection.vala | 89 ++
gee/abstractlist.vala | 85 ++
gee/abstractmap.vala | 131 +++
gee/abstractmultimap.vala | 311 ++++++
gee/abstractmultiset.vala | 180 +++
gee/abstractqueue.vala | 55 +
gee/abstractset.vala | 50 +
gee/abstractsortedmap.vala | 65 ++
gee/abstractsortedset.vala | 98 ++
gee/arraylist.vala | 298 +++++-
gee/arrayqueue.vala | 342 ++++++
gee/bidiriterator.vala | 55 +
gee/bidirlist.vala | 35 +
gee/bidirlistiterator.vala | 30 +
gee/bidirmapiterator.vala | 56 +
gee/bidirsortedmap.vala | 45 +
gee/bidirsortedset.vala | 46 +
gee/collection.vala | 241 ++++-
gee/comparable.vala | 37 +
gee/concurrentlist.vala | 587 ++++++++++
gee/deque.vala | 123 ++
gee/functions.vala | 152 +++
gee/hashable.vala | 44 +
gee/hashmap.vala | 618 ++++++++---
gee/hashmultimap.vala | 76 ++
gee/hashmultiset.vala | 47 +
gee/hashset.vala | 221 +++-
gee/hazardpointer.vala | 775 +++++++++++++
gee/iterable.vala | 12 +-
gee/iterator.vala | 86 ++-
gee/lazy.vala | 60 +
gee/linkedlist.vala | 690 ++++++++++++
gee/list.vala | 90 ++-
gee/listiterator.vala | 44 +
gee/map.vala | 197 +++-
gee/mapiterator.vala | 111 ++-
gee/multimap.vala | 127 +++
gee/multiset.vala | 36 +
gee/priorityqueue.vala | 1207 ++++++++++++++++++++
gee/queue.vala | 115 ++
gee/readonlybidirlist.vala | 73 ++
gee/readonlybidirsortedmap.vala | 80 ++
gee/readonlybidirsortedset.vala | 71 ++
gee/readonlycollection.vala | 235 ++++
gee/readonlylist.vala | 149 +++
gee/readonlymap.vala | 297 +++++
gee/readonlyset.vala | 50 +
gee/readonlysortedmap.vala | 90 ++
gee/readonlysortedset.vala | 123 ++
gee/set.vala | 19 +-
gee/sortedmap.vala | 66 ++
gee/sortedset.vala | 137 +++
gee/timsort.vala | 713 ++++++++++++
gee/traversable.vala | 379 +++++++
gee/treemap.vala | 1914 ++++++++++++++++++++++++++++++++
gee/treemultimap.vala | 63 ++
gee/treemultiset.vala | 43 +
gee/treeset.vala | 1162 +++++++++++++++++++
gee/unfolditerator.vala | 102 ++
vala/valaattribute.vala | 4 +-
vala/valacodecontext.vala | 4 +-
vala/valacodenode.vala | 2 +-
vala/valacodewriter.vala | 2 +-
vala/valaflowanalyzer.vala | 2 +-
vala/valagirparser.vala | 18 +-
vala/valamarkupreader.vala | 6 +-
vala/valascope.vala | 4 +-
vala/valaswitchstatement.vala | 2 +-
vala/valausedattr.vala | 6 +-
vapigen/valagidlparser.vala | 26 +-
vapigen/valavapicheck.vala | 2 +-
85 files changed, 13457 insertions(+), 404 deletions(-)
---
diff --git a/ccode/valaccodefile.vala b/ccode/valaccodefile.vala
index 128cd39..0b256e5 100644
--- a/ccode/valaccodefile.vala
+++ b/ccode/valaccodefile.vala
@@ -24,8 +24,8 @@
public class Vala.CCodeFile {
public bool is_header { get; set; }
- Set<string> declarations = new HashSet<string> (str_hash, str_equal);
- Set<string> includes = new HashSet<string> (str_hash, str_equal);
+ Set<string> declarations = new HashSet<string> ();
+ Set<string> includes = new HashSet<string> ();
CCodeFragment comments = new CCodeFragment ();
CCodeFragment include_directives = new CCodeFragment ();
CCodeFragment type_declaration = new CCodeFragment ();
diff --git a/codegen/valaccodebasemodule.vala b/codegen/valaccodebasemodule.vala
index 32f461a..4645955 100644
--- a/codegen/valaccodebasemodule.vala
+++ b/codegen/valaccodebasemodule.vala
@@ -38,8 +38,8 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
public int next_temp_var_id;
public bool current_method_inner_error;
public bool current_method_return;
- public Map<string,string> variable_name_map = new HashMap<string,string> (str_hash,
str_equal);
- public Map<string,int> closure_variable_count_map = new HashMap<string,int> (str_hash,
str_equal);
+ public Map<string,string> variable_name_map = new HashMap<string,string> ();
+ public Map<string,int> closure_variable_count_map = new HashMap<string,int> ();
public Map<LocalVariable,int> closure_variable_clash_map = new HashMap<LocalVariable,int> ();
public EmitContext (Symbol? symbol = null) {
@@ -341,7 +341,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
public static int ccode_attribute_cache_index = CodeNode.get_attribute_cache_index ();
public CCodeBaseModule () {
- predefined_marshal_set = new HashSet<string> (str_hash, str_equal);
+ predefined_marshal_set = new HashSet<string> ();
predefined_marshal_set.add ("VOID:VOID");
predefined_marshal_set.add ("VOID:BOOLEAN");
predefined_marshal_set.add ("VOID:CHAR");
@@ -361,7 +361,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
predefined_marshal_set.add ("VOID:UINT,POINTER");
predefined_marshal_set.add ("BOOLEAN:FLAGS");
- reserved_identifiers = new HashSet<string> (str_hash, str_equal);
+ reserved_identifiers = new HashSet<string> ();
// C99 keywords
reserved_identifiers.add ("_Bool");
@@ -712,7 +712,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
public override void visit_source_file (SourceFile source_file) {
cfile = new CCodeFile ();
- user_marshal_set = new HashSet<string> (str_hash, str_equal);
+ user_marshal_set = new HashSet<string> ();
next_regex_id = 0;
@@ -723,7 +723,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
requires_array_length = false;
requires_clear_mutex = false;
- wrappers = new HashSet<string> (str_hash, str_equal);
+ wrappers = new HashSet<string> ();
generated_external_symbols = new HashSet<Symbol> ();
header_file.add_include ("glib.h");
@@ -2269,7 +2269,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
return "result";
}
// compiler-internal variable
- if (!variable_name_map.contains (name)) {
+ if (!variable_name_map.has_key (name)) {
variable_name_map.set (name, "_tmp%d_".printf (next_temp_var_id));
next_temp_var_id++;
}
@@ -4566,7 +4566,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
generate_type_declaration (expr.type_reference, cfile);
- var in_arg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ var in_arg_map = new HashMap<int,CCodeExpression> ();
var out_arg_map = in_arg_map;
if (m != null && m.coroutine) {
@@ -4578,7 +4578,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
creation_call = finish_call;
// output arguments used separately
- out_arg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ out_arg_map = new HashMap<int,CCodeExpression> ();
// pass GAsyncResult stored in closure to finish function
out_arg_map.set (get_param_pos (0.1), new CCodeMemberAccess.pointer (new
CCodeIdentifier ("_data_"), "_res_"));
}
@@ -4712,7 +4712,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
last_pos = -1;
while (true) {
min_pos = -1;
- foreach (int pos in out_arg_map.get_keys ()) {
+ foreach (int pos in out_arg_map.keys) {
if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
min_pos = pos;
}
@@ -4729,7 +4729,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator {
last_pos = -1;
while (true) {
min_pos = -1;
- foreach (int pos in in_arg_map.get_keys ()) {
+ foreach (int pos in in_arg_map.keys) {
if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
min_pos = pos;
}
diff --git a/codegen/valaccodedelegatemodule.vala b/codegen/valaccodedelegatemodule.vala
index f97420f..e278360 100644
--- a/codegen/valaccodedelegatemodule.vala
+++ b/codegen/valaccodedelegatemodule.vala
@@ -207,7 +207,7 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
push_function (function);
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
if (d.has_target) {
var cparam = new CCodeParameter ("self", "gpointer");
@@ -268,7 +268,7 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
int min_pos;
while (true) {
min_pos = -1;
- foreach (int pos in cparam_map.get_keys ()) {
+ foreach (int pos in cparam_map.keys) {
if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
min_pos = pos;
}
@@ -283,7 +283,7 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
// definition
- var carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ var carg_map = new HashMap<int,CCodeExpression> ();
int i = 0;
if (m.binding == MemberBinding.INSTANCE || m.closure) {
@@ -392,7 +392,7 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
last_pos = -1;
while (true) {
min_pos = -1;
- foreach (int pos in carg_map.get_keys ()) {
+ foreach (int pos in carg_map.keys) {
if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
min_pos = pos;
}
diff --git a/codegen/valaccodemethodcallmodule.vala b/codegen/valaccodemethodcallmodule.vala
index 8e923ea..e1a4cae 100644
--- a/codegen/valaccodemethodcallmodule.vala
+++ b/codegen/valaccodemethodcallmodule.vala
@@ -78,7 +78,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
deleg = ((DelegateType) itype).delegate_symbol;
}
- var in_arg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ var in_arg_map = new HashMap<int,CCodeExpression> ();
var out_arg_map = in_arg_map;
if (m != null && m.coroutine) {
@@ -120,7 +120,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
ccall = finish_call;
// output arguments used separately
- out_arg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ out_arg_map = new HashMap<int,CCodeExpression> ();
// pass GAsyncResult stored in closure to finish function
out_arg_map.set (get_param_pos (0.1), new CCodeMemberAccess.pointer (new
CCodeIdentifier ("_data_"), "_res_"));
}
@@ -657,7 +657,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
last_pos = -1;
while (true) {
min_pos = -1;
- foreach (int pos in out_arg_map.get_keys ()) {
+ foreach (int pos in out_arg_map.keys) {
if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
min_pos = pos;
}
@@ -674,7 +674,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
last_pos = -1;
while (true) {
min_pos = -1;
- foreach (int pos in in_arg_map.get_keys ()) {
+ foreach (int pos in in_arg_map.keys) {
if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
min_pos = pos;
}
diff --git a/codegen/valaccodemethodmodule.vala b/codegen/valaccodemethodmodule.vala
index d147eb1..2bc181d 100644
--- a/codegen/valaccodemethodmodule.vala
+++ b/codegen/valaccodemethodmodule.vala
@@ -173,8 +173,8 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule {
function.modifiers |= CCodeModifiers.DEPRECATED;
}
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- var carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
+ var carg_map = new HashMap<int,CCodeExpression> ();
var cl = m.parent_symbol as Class;
@@ -198,7 +198,7 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule {
function.modifiers |= CCodeModifiers.INTERNAL;
}
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
bool etv_tmp = ellipses_to_valist;
ellipses_to_valist = false;
generate_cparameters (m, decl_space, cparam_map, function);
@@ -210,7 +210,7 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule {
// _constructv function
function = new CCodeFunction (get_ccode_constructv_name ((CreationMethod) m));
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, decl_space, cparam_map, function);
decl_space.add_function_declaration (function);
@@ -416,7 +416,7 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule {
function.modifiers |= CCodeModifiers.INLINE;
}
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, cfile, cparam_map, function);
@@ -815,8 +815,8 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule {
* emitter! */
m.signal_reference == null) {
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- var carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
+ var carg_map = new HashMap<int,CCodeExpression> ();
generate_vfunc (m, creturn_type, cparam_map, carg_map);
}
@@ -1015,7 +1015,7 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule {
int min_pos;
while (true) {
min_pos = -1;
- foreach (int pos in cparam_map.get_keys ()) {
+ foreach (int pos in cparam_map.keys) {
if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
min_pos = pos;
}
@@ -1193,8 +1193,8 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule {
vfunc.modifiers |= CCodeModifiers.INTERNAL;
}
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- var carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
+ var carg_map = new HashMap<int,CCodeExpression> ();
push_function (vfunc);
@@ -1214,7 +1214,7 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule {
if (m.is_variadic ()) {
int last_pos = -1;
int second_last_pos = -1;
- foreach (int pos in cparam_map.get_keys ()) {
+ foreach (int pos in cparam_map.keys) {
if (pos > last_pos) {
second_last_pos = last_pos;
last_pos = pos;
diff --git a/codegen/valagasyncmodule.vala b/codegen/valagasyncmodule.vala
index 928e67b..63469f1 100644
--- a/codegen/valagasyncmodule.vala
+++ b/codegen/valagasyncmodule.vala
@@ -155,7 +155,7 @@ public class Vala.GAsyncModule : GtkModule {
var dataname = Symbol.lower_case_to_camel_case (get_ccode_name (m)) + "Data";
var asyncfunc = new CCodeFunction (get_ccode_real_name (m), "void");
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
cparam_map.set (get_param_pos (-1), new CCodeParameter ("_callback_", "GAsyncReadyCallback"));
cparam_map.set (get_param_pos (-0.9), new CCodeParameter ("_user_data_", "gpointer"));
@@ -304,8 +304,8 @@ public class Vala.GAsyncModule : GtkModule {
var cl = m.parent_symbol as Class;
var asyncfunc = new CCodeFunction (get_ccode_name (m), "void");
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- var carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
+ var carg_map = new HashMap<int,CCodeExpression> ();
if (m.is_private_symbol ()) {
asyncfunc.modifiers |= CCodeModifiers.STATIC;
@@ -321,8 +321,8 @@ public class Vala.GAsyncModule : GtkModule {
}
var finishfunc = new CCodeFunction (get_ccode_finish_name (m));
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
+ carg_map = new HashMap<int,CCodeExpression> ();
if (m.is_private_symbol ()) {
finishfunc.modifiers |= CCodeModifiers.STATIC;
@@ -347,7 +347,7 @@ public class Vala.GAsyncModule : GtkModule {
function.modifiers |= CCodeModifiers.INTERNAL;
}
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, decl_space, cparam_map, function, null, null, null,
1);
decl_space.add_function_declaration (function);
@@ -360,7 +360,7 @@ public class Vala.GAsyncModule : GtkModule {
function.modifiers |= CCodeModifiers.INTERNAL;
}
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, decl_space, cparam_map, function, null, null, null,
2);
decl_space.add_function_declaration (function);
@@ -406,12 +406,12 @@ public class Vala.GAsyncModule : GtkModule {
if (m.is_abstract || m.is_virtual) {
// generate virtual function wrappers
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- var carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
+ var carg_map = new HashMap<int,CCodeExpression> ();
generate_vfunc (m, new VoidType (), cparam_map, carg_map, "", 1);
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
+ carg_map = new HashMap<int,CCodeExpression> ();
generate_vfunc (m, m.return_type, cparam_map, carg_map, "_finish", 2);
}
} else {
@@ -437,8 +437,8 @@ public class Vala.GAsyncModule : GtkModule {
if (current_type_symbol is Class && !current_class.is_compact &&
!current_class.is_abstract) {
var vfunc = new CCodeFunction (get_ccode_name (m));
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- var carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
+ var carg_map = new HashMap<int,CCodeExpression> ();
push_function (vfunc);
@@ -459,8 +459,8 @@ public class Vala.GAsyncModule : GtkModule {
vfunc = new CCodeFunction (get_ccode_finish_name (m));
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
- carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
+ carg_map = new HashMap<int,CCodeExpression> ();
push_function (vfunc);
@@ -489,7 +489,7 @@ public class Vala.GAsyncModule : GtkModule {
var finishfunc = new CCodeFunction (get_ccode_finish_real_name (m));
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
cparam_map.set (get_param_pos (0.1), new CCodeParameter ("_res_", "GAsyncResult*"));
@@ -637,7 +637,7 @@ public class Vala.GAsyncModule : GtkModule {
// add vfunc field to the type struct
var vdeclarator = new CCodeFunctionDeclarator (get_ccode_vfunc_name (m));
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, decl_space, cparam_map, new CCodeFunction ("fake"), vdeclarator,
null, null, 1);
@@ -647,7 +647,7 @@ public class Vala.GAsyncModule : GtkModule {
// add vfunc field to the type struct
vdeclarator = new CCodeFunctionDeclarator (get_ccode_finish_vfunc_name (m));
- cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, decl_space, cparam_map, new CCodeFunction ("fake"), vdeclarator,
null, null, 2);
diff --git a/codegen/valagdbusclientmodule.vala b/codegen/valagdbusclientmodule.vala
index 7ec2387..b12c958 100644
--- a/codegen/valagdbusclientmodule.vala
+++ b/codegen/valagdbusclientmodule.vala
@@ -48,7 +48,7 @@ public class Vala.GDBusClientModule : GDBusModule {
var func = new CCodeFunction (get_ccode_name (method));
func.modifiers = CCodeModifiers.STATIC;
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (method, cfile, cparam_map, func);
@@ -861,7 +861,7 @@ public class Vala.GDBusClientModule : GDBusModule {
var function = new CCodeFunction (proxy_name);
function.modifiers = CCodeModifiers.STATIC;
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, cfile, cparam_map, function);
@@ -885,7 +885,7 @@ public class Vala.GDBusClientModule : GDBusModule {
var function = new CCodeFunction (proxy_name, "void");
function.modifiers = CCodeModifiers.STATIC;
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
cparam_map.set (get_param_pos (-1), new CCodeParameter ("_callback_", "GAsyncReadyCallback"));
cparam_map.set (get_param_pos (-0.9), new CCodeParameter ("_user_data_", "gpointer"));
@@ -910,7 +910,7 @@ public class Vala.GDBusClientModule : GDBusModule {
var function = new CCodeFunction (proxy_name);
function.modifiers = CCodeModifiers.STATIC;
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
cparam_map.set (get_param_pos (0.1), new CCodeParameter ("_res_", "GAsyncResult*"));
diff --git a/codegen/valagirwriter.vala b/codegen/valagirwriter.vala
index 3f4d15d..205c933 100644
--- a/codegen/valagirwriter.vala
+++ b/codegen/valagirwriter.vala
@@ -102,10 +102,10 @@ public class Vala.GIRWriter : CodeVisitor {
StringBuilder buffer = new StringBuilder();
FileStream stream;
- Vala.HashSet<Namespace> unannotated_namespaces = new Vala.HashSet<Namespace>();
- Vala.HashSet<Namespace> our_namespaces = new Vala.HashSet<Namespace>();
- Vala.ArrayList<Vala.Symbol> hierarchy = new Vala.ArrayList<Vala.Symbol>();
- Vala.ArrayList<Vala.CodeNode> deferred = new Vala.ArrayList<Vala.CodeNode>();
+ HashSet<Namespace> unannotated_namespaces = new HashSet<Namespace>();
+ HashSet<Namespace> our_namespaces = new HashSet<Namespace>();
+ ArrayList<Vala.Symbol> hierarchy = new ArrayList<Vala.Symbol>();
+ ArrayList<Vala.CodeNode> deferred = new ArrayList<Vala.CodeNode>();
int indent;
@@ -123,7 +123,7 @@ public class Vala.GIRWriter : CodeVisitor {
}
}
- private ArrayList<GIRNamespace?> externals = new ArrayList<GIRNamespace?> ((EqualFunc<GIRNamespace>)
GIRNamespace.equal);
+ private ArrayList<GIRNamespace?> externals = new ArrayList<GIRNamespace?> ((a, b) => { return a.equal
(b); });
public void write_includes() {
foreach (var i in externals) {
@@ -214,11 +214,11 @@ public class Vala.GIRWriter : CodeVisitor {
private void write_c_includes (Namespace ns) {
// Collect C header filenames
- Set<string> header_filenames = new HashSet<string> (str_hash, str_equal);
+ Set<string> header_filenames = new HashSet<string> ();
foreach (string c_header_filename in CCodeBaseModule.get_ccode_header_filenames (ns).split
(",")) {
header_filenames.add (c_header_filename);
}
- foreach (Symbol symbol in ns.scope.get_symbol_table ().get_values ()) {
+ foreach (Symbol symbol in ns.scope.get_symbol_table ().values) {
foreach (string c_header_filename in CCodeBaseModule.get_ccode_header_filenames
(symbol).split (",")) {
header_filenames.add (c_header_filename);
}
@@ -621,7 +621,7 @@ public class Vala.GIRWriter : CodeVisitor {
private void visit_deferred () {
var nodes = this.deferred;
- this.deferred = new Vala.ArrayList<Vala.CodeNode>();
+ this.deferred = new ArrayList<Vala.CodeNode>();
foreach (var node in nodes) {
node.accept (this);
@@ -1361,7 +1361,7 @@ public class Vala.GIRWriter : CodeVisitor {
private void write_annotations (CodeNode node) {
foreach (Attribute attr in node.attributes) {
string name = camel_case_to_canonical (attr.name);
- foreach (string arg_name in attr.args.get_keys ()) {
+ foreach (string arg_name in attr.args.keys) {
string value = attr.args.get (arg_name);
if (value.has_prefix ("\"")) {
// eval string
diff --git a/codegen/valagtkmodule.vala b/codegen/valagtkmodule.vala
index 07c022e..6799ee9 100644
--- a/codegen/valagtkmodule.vala
+++ b/codegen/valagtkmodule.vala
@@ -28,9 +28,9 @@ public class Vala.GtkModule : GSignalModule {
/* GResource name to real file name mapping */
private HashMap<string, string> gresource_to_file_map = null;
/* GtkBuilder xml handler to Vala signal mapping */
- private HashMap<string, Signal> current_handler_to_signal_map = new HashMap<string, Signal>(str_hash,
str_equal);
+ private HashMap<string, Signal> current_handler_to_signal_map = new HashMap<string, Signal>();
/* GtkBuilder xml child to Vala class mapping */
- private HashMap<string, Class> current_child_to_class_map = new HashMap<string, Class>(str_hash,
str_equal);
+ private HashMap<string, Class> current_child_to_class_map = new HashMap<string, Class>();
/* Required custom application-specific gtype classes to be ref'd before initializing the template */
private HashSet<Class> current_required_app_classes = new HashSet<Class>();
@@ -39,7 +39,7 @@ public class Vala.GtkModule : GSignalModule {
if (cclass_to_vala_map != null) {
return;
}
- cclass_to_vala_map = new HashMap<string, Class>(str_hash, str_equal);
+ cclass_to_vala_map = new HashMap<string, Class>();
recurse_cclass_to_vala_map (context.root);
}
@@ -59,7 +59,7 @@ public class Vala.GtkModule : GSignalModule {
if (gresource_to_file_map != null) {
return;
}
- gresource_to_file_map = new HashMap<string, string>(str_hash, str_equal);
+ gresource_to_file_map = new HashMap<string, string>();
foreach (var gresource in context.gresources) {
if (!FileUtils.test (gresource, FileTest.EXISTS)) {
Report.error (null, "GResources file `%s' does not exist".printf (gresource));
@@ -107,8 +107,8 @@ public class Vala.GtkModule : GSignalModule {
Report.error (node.source_reference, "UI resource not found: `%s'. Please make sure
to specify the proper GResources xml files with --gresources.".printf (ui_resource));
return;
}
- current_handler_to_signal_map = new HashMap<string, Signal>(str_hash, str_equal);
- current_child_to_class_map = new HashMap<string, Class>(str_hash, str_equal);
+ current_handler_to_signal_map = new HashMap<string, Signal>();
+ current_child_to_class_map = new HashMap<string, Class>();
MarkupReader reader = new MarkupReader (ui_file);
Class current_class = null;
diff --git a/codegen/valagtypemodule.vala b/codegen/valagtypemodule.vala
index b732886..0e8ff0d 100644
--- a/codegen/valagtypemodule.vala
+++ b/codegen/valagtypemodule.vala
@@ -392,7 +392,7 @@ public class Vala.GTypeModule : GErrorModule {
// add vfunc field to the type struct
var vdeclarator = new CCodeFunctionDeclarator (get_ccode_vfunc_name (m));
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, decl_space, cparam_map, new CCodeFunction ("fake"), vdeclarator);
@@ -1492,7 +1492,7 @@ public class Vala.GTypeModule : GErrorModule {
string cast_args = get_ccode_name (base_type) + "*";
var vdeclarator = new CCodeFunctionDeclarator (get_ccode_vfunc_name (m));
- var cparam_map = new HashMap<int,CCodeParameter> (direct_hash, direct_equal);
+ var cparam_map = new HashMap<int,CCodeParameter> ();
generate_cparameters (m, cfile, cparam_map, new CCodeFunction ("fake"), vdeclarator);
@@ -1501,7 +1501,7 @@ public class Vala.GTypeModule : GErrorModule {
int min_pos;
while (true) {
min_pos = -1;
- foreach (int pos in cparam_map.get_keys ()) {
+ foreach (int pos in cparam_map.keys) {
if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
min_pos = pos;
}
diff --git a/gee/Makefile.am b/gee/Makefile.am
index db4e75b..e57a70c 100644
--- a/gee/Makefile.am
+++ b/gee/Makefile.am
@@ -14,16 +14,68 @@ noinst_LTLIBRARIES = \
$(NULL)
libgee_la_VALASOURCES = \
+ abstractbidirlist.vala \
+ abstractbidirsortedmap.vala \
+ abstractbidirsortedset.vala \
+ abstractcollection.vala \
+ abstractlist.vala \
+ abstractmap.vala \
+ abstractmultimap.vala \
+ abstractmultiset.vala \
+ abstractqueue.vala \
+ abstractset.vala \
+ abstractsortedmap.vala \
+ abstractsortedset.vala \
arraylist.vala \
+ arrayqueue.vala \
+ bidiriterator.vala \
+ bidirlistiterator.vala \
+ bidirlist.vala \
+ bidirmapiterator.vala \
+ bidirsortedmap.vala \
+ bidirsortedset.vala \
collection.vala \
+ comparable.vala \
+ concurrentlist.vala \
+ deque.vala \
+ functions.vala \
+ hashable.vala \
hashmap.vala \
+ hashmultimap.vala \
+ hashmultiset.vala \
hashset.vala \
+ hazardpointer.vala \
iterable.vala \
- mapiterator.vala \
iterator.vala \
+ lazy.vala \
+ linkedlist.vala \
+ listiterator.vala \
list.vala \
+ mapiterator.vala \
map.vala \
+ multimap.vala \
+ multiset.vala \
+ priorityqueue.vala \
+ queue.vala \
+ readonlybidirlist.vala \
+ readonlybidirsortedmap.vala \
+ readonlybidirsortedset.vala \
+ readonlycollection.vala \
+ readonlylist.vala \
+ readonlymap.vala \
+ readonlyset.vala \
+ readonlysortedmap.vala \
+ readonlysortedset.vala \
set.vala \
+ sortedmap.vala \
+ sortedset.vala \
+ timsort.vala \
+ traversable.vala \
+ treemap.vala \
+ treemultimap.vala \
+ treemultiset.vala \
+ treeset.vala \
+ unfolditerator.vala \
$(NULL)
libgee_la_SOURCES = \
diff --git a/gee/abstractbidirlist.vala b/gee/abstractbidirlist.vala
new file mode 100644
index 0000000..41040f5
--- /dev/null
+++ b/gee/abstractbidirlist.vala
@@ -0,0 +1,46 @@
+/* bidirlistiterator.vala
+ *
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+public abstract class Vala.AbstractBidirList<G> : AbstractList<G>, BidirList<G> {
+ /**
+ * {@inheritDoc}
+ */
+ public abstract BidirListIterator<G> bidir_list_iterator ();
+
+ private weak BidirList<G> _read_only_view;
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual new BidirList<G> read_only_view {
+ owned get {
+ BidirList<G> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlyBidirList<G> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+}
+
diff --git a/gee/abstractbidirsortedmap.vala b/gee/abstractbidirsortedmap.vala
new file mode 100644
index 0000000..2290c17
--- /dev/null
+++ b/gee/abstractbidirsortedmap.vala
@@ -0,0 +1,53 @@
+/* abstractbidirsortedmap.vala
+ *
+ * Copyright (C) 2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Skeletal implementation of the {@link BidirSortedSet} interface.
+ *
+ * Contains common code shared by all set implementations.
+ *
+ * @see TreeSet
+ */
+public abstract class Vala.AbstractBidirSortedMap<K,V> : Vala.AbstractSortedMap<K,V>, BidirSortedMap<K,V> {
+ /**
+ * {@inheritDoc}
+ */
+ public abstract BidirMapIterator<K,V> bidir_map_iterator ();
+
+ private weak BidirSortedMap<K,V> _read_only_view;
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual new BidirSortedMap<K,V> read_only_view {
+ owned get {
+ BidirSortedMap<K,V> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlyBidirSortedMap<K,V> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+}
+
diff --git a/gee/abstractbidirsortedset.vala b/gee/abstractbidirsortedset.vala
new file mode 100644
index 0000000..219664a
--- /dev/null
+++ b/gee/abstractbidirsortedset.vala
@@ -0,0 +1,53 @@
+/* abstractbidirsortedset.vala
+ *
+ * Copyright (C) 2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Skeletal implementation of the {@link BidirSortedSet} interface.
+ *
+ * Contains common code shared by all set implementations.
+ *
+ * @see TreeSet
+ */
+public abstract class Vala.AbstractBidirSortedSet<G> : Vala.AbstractSortedSet<G>, BidirSortedSet<G> {
+ /**
+ * {@inheritDoc}
+ */
+ public abstract BidirIterator<G> bidir_iterator ();
+
+ private weak BidirSortedSet<G> _read_only_view;
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual new BidirSortedSet<G> read_only_view {
+ owned get {
+ BidirSortedSet<G> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlyBidirSortedSet<G> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+}
+
diff --git a/gee/abstractcollection.vala b/gee/abstractcollection.vala
new file mode 100644
index 0000000..a2421ce
--- /dev/null
+++ b/gee/abstractcollection.vala
@@ -0,0 +1,89 @@
+/* abstractcollection.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes' Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Skeletal implementation of the {@link Collection} interface.
+ *
+ * Contains common code shared by all collection implementations.
+ *
+ * @see AbstractList
+ * @see AbstractSet
+ * @see AbstractMultiSet
+ */
+public abstract class Vala.AbstractCollection<G> : Object, Traversable<G>, Iterable<G>, Collection<G> {
+ /**
+ * {@inheritDoc}
+ */
+ public abstract int size { get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool read_only { get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool contains (G item);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool add (G item);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool remove (G item);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract void clear ();
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract Iterator<G> iterator ();
+
+ public virtual bool foreach (ForallFunc<G> f) {
+ return iterator ().foreach (f);
+ }
+
+ private weak Collection<G> _read_only_view;
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual Collection<G> read_only_view {
+ owned get {
+ Collection<G> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlyCollection<G> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+}
diff --git a/gee/abstractlist.vala b/gee/abstractlist.vala
new file mode 100644
index 0000000..581ad7f
--- /dev/null
+++ b/gee/abstractlist.vala
@@ -0,0 +1,85 @@
+/* abstractlist.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes' Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Skeletal implementation of the {@link List} interface.
+ *
+ * Contains common code shared by all list implementations.
+ *
+ * @see ArrayList
+ * @see LinkedList
+ */
+public abstract class Vala.AbstractList<G> : Vala.AbstractCollection<G>, List<G> {
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract ListIterator<G> list_iterator ();
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract new G? get (int index);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract new void set (int index, G item);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract int index_of (G item);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract void insert (int index, G item);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G remove_at (int index);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract List<G>? slice (int start, int stop);
+
+ private weak List<G> _read_only_view;
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual new List<G> read_only_view {
+ owned get {
+ List<G> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlyList<G> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+}
diff --git a/gee/abstractmap.vala b/gee/abstractmap.vala
new file mode 100644
index 0000000..bc24604
--- /dev/null
+++ b/gee/abstractmap.vala
@@ -0,0 +1,131 @@
+/* abstractmap.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Tomaž Vajngerl <quikee gmail com>
+ */
+
+/**
+ * Skeletal implementation of the {@link Map} interface.
+ *
+ * Contains common code shared by all map implementations.
+ *
+ * @see HashMap
+ * @see TreeMap
+ */
+public abstract class Vala.AbstractMap<K,V> : Object, Traversable<Map.Entry<K,V>>, Iterable<Map.Entry<K,V>>,
Map<K,V> {
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract int size { get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool read_only { get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract Set<K> keys { owned get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract Collection<V> values { owned get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract Set<Map.Entry<K,V>> entries { owned get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool has_key (K key);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool has (K key, V value);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract new V? get (K key);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract new void set (K key, V value);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool unset (K key, out V? value = null);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract MapIterator<K,V> map_iterator ();
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract void clear ();
+
+ private weak Map<K,V> _read_only_view;
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual Map<K,V> read_only_view {
+ owned get {
+ Map<K,V> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlyMap<K,V> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Iterator<Map.Entry<K,V>> iterator () {
+ return entries.iterator ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual bool foreach (ForallFunc<Map.Entry<K,V>> f) {
+ return iterator ().foreach (f);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual Iterator<A> stream<A> (owned StreamFunc<Map.Entry<K,V>, A> f) {
+ return iterator ().stream<A> ((owned) f);
+ }
+}
diff --git a/gee/abstractmultimap.vala b/gee/abstractmultimap.vala
new file mode 100644
index 0000000..9c96c70
--- /dev/null
+++ b/gee/abstractmultimap.vala
@@ -0,0 +1,311 @@
+/* abstractmultimap.vala
+ *
+ * Copyright (C) 2009 Ali Sabil
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Ali Sabil <ali sabil gmail com>
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Skeletal implementation of the {@link MultiMap} interface.
+ *
+ * @see HashMultiMap
+ * @see TreeMultiMap
+ */
+public abstract class Vala.AbstractMultiMap<K,V> : Object, MultiMap<K,V> {
+ public int size {
+ get { return _nitems; }
+ }
+
+ public bool read_only {
+ get { return false; }
+ }
+
+ protected Map<K, Collection<V>> _storage_map;
+ private int _nitems = 0;
+
+ public AbstractMultiMap (Map<K, Collection<V>> storage_map) {
+ this._storage_map = storage_map;
+ }
+
+ public Set<K> get_keys () {
+ return _storage_map.keys;
+ }
+
+ public MultiSet<K> get_all_keys () {
+ return new AllKeys<K, V> (this);
+ }
+
+ public Collection<V> get_values () {
+ return new Values<K, V> (this);
+ }
+
+ public bool contains (K key) {
+ return _storage_map.has_key (key);
+ }
+
+ public new Collection<V> get (K key) {
+ Collection<V>? col = _storage_map.get (key);
+ return col != null ? col.read_only_view : Set.empty<V> ();
+ }
+
+ public new void set (K key, V value) {
+ if (_storage_map.has_key (key)) {
+ if (_storage_map.get (key).add (value)) {
+ _nitems++;
+ }
+ } else {
+ var s = create_value_storage ();
+ s.add (value);
+ _storage_map.set (key, s);
+ _nitems++;
+ }
+ }
+
+ public bool remove (K key, V value) {
+ if (_storage_map.has_key (key)) {
+ var values = _storage_map.get (key);
+ if (values.contains (value)) {
+ values.remove (value);
+ _nitems--;
+ if (values.size == 0) {
+ _storage_map.unset (key);
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public bool remove_all (K key) {
+ if (_storage_map.has_key (key)) {
+ int size = _storage_map.get (key).size;
+ if (_storage_map.unset (key)) {
+ _nitems -= size;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public void clear () {
+ _storage_map.clear ();
+ _nitems = 0;
+ }
+
+ public Vala.MapIterator<K, V> map_iterator () {
+ return new MapIterator<K, V> (_storage_map.map_iterator ());
+ }
+
+ protected abstract Collection<V> create_value_storage ();
+
+ protected abstract MultiSet<K> create_multi_key_set ();
+
+ protected abstract EqualDataFunc<V> get_value_equal_func ();
+
+ private class AllKeys<K, V> : AbstractCollection<K>, MultiSet<K> {
+ protected AbstractMultiMap<K, V> _multi_map;
+
+ public AllKeys (AbstractMultiMap<K, V> multi_map) {
+ _multi_map = multi_map;
+ }
+
+ public override Vala.Iterator<K> iterator () {
+ return new KeyIterator<K, V> (_multi_map._storage_map.map_iterator ());
+ }
+
+ public override int size { get { return _multi_map.size; } }
+
+ public override bool read_only { get { return true; } }
+
+ public override bool contains (K key) {
+ return _multi_map._storage_map.has_key (key);
+ }
+
+ public override bool add (K key) {
+ assert_not_reached ();
+ }
+
+ public override bool remove (K item) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public int count (K item) {
+ Collection<V>? collection = _multi_map._storage_map.get (item);
+ return collection != null ? collection.size : 0;
+ }
+ }
+
+ private class Values<K, V> : AbstractCollection<V> {
+ protected AbstractMultiMap<K, V> _multi_map;
+
+ public Values (AbstractMultiMap<K, V> multi_map) {
+ _multi_map = multi_map;
+ }
+
+ public override Vala.Iterator<K> iterator () {
+ return new ValueIterator<K, V> (_multi_map._storage_map.map_iterator ());
+ }
+
+ public override int size { get { return _multi_map.size; } }
+
+ public override bool read_only { get { return true; } }
+
+ public override bool contains (V value) {
+ foreach (var col in _multi_map._storage_map.values) {
+ if (col.contains (value)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public override bool add (V key) {
+ assert_not_reached ();
+ }
+
+ public override bool remove (V item) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+ }
+
+ private class MappingIterator<K, V> : Object {
+ protected Vala.MapIterator<K, Collection<V>> outer;
+ protected Iterator<V>? inner = null;
+
+ public MappingIterator (Vala.MapIterator<K, Collection<V>>? outer) {
+ this.outer = outer;
+ }
+
+ public bool next () {
+ if (inner != null && inner.next ()) {
+ return true;
+ } else if (outer.next ()) {
+ inner = outer.get_value ().iterator ();
+ assert (inner.next ());
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public bool has_next () {
+ return inner.has_next () || outer.has_next ();
+ }
+
+ public void remove () {
+ assert_not_reached ();
+ }
+
+ public virtual bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public void unset () {
+ inner.remove ();
+ if (outer.get_value ().is_empty) {
+ outer.unset ();
+ }
+ }
+
+ public bool valid {
+ get {
+ return inner != null && inner.valid;
+ }
+ }
+ }
+
+ private class KeyIterator<K, V> : MappingIterator<K, V>, Traversable<K>, Iterator<K> {
+ public KeyIterator (Vala.MapIterator<K, Collection<V>>? outer) {
+ base (outer);
+ }
+
+ public new K get () {
+ assert (valid);
+ return outer.get_key ();
+ }
+
+ public bool foreach (ForallFunc<K> f) {
+ if (inner != null && outer.valid) {
+ K key = outer.get_key ();
+ if (!inner.foreach ((v) => {return f (key);})) {
+ return false;
+ }
+ outer.next ();
+ }
+ return outer.foreach ((key, col) => {
+ return col.foreach ((v) => {return f (key);});
+ });
+ }
+ }
+
+ private class ValueIterator<K, V> : MappingIterator<K, V>, Traversable<V>, Iterator<V> {
+ public ValueIterator (Vala.MapIterator<K, Collection<V>>? outer) {
+ base (outer);
+ }
+
+ public new V get () {
+ assert (valid);
+ return inner.get ();
+ }
+
+ public bool foreach (ForallFunc<V> f) {
+ if (inner != null && outer.valid) {
+ if (!inner.foreach (f)) {
+ return false;
+ }
+ outer.next ();
+ }
+ return outer.foreach ((key, col) => {
+ return col.foreach (f);
+ });
+ }
+ }
+
+ private class MapIterator<K, V> : MappingIterator<K, V>, Vala.MapIterator<K, V> {
+ public MapIterator (Vala.MapIterator<K, Collection<V>>? outer) {
+ base (outer);
+ }
+
+ public K get_key () {
+ assert (valid);
+ return outer.get_key ();
+ }
+
+ public V get_value () {
+ assert (valid);
+ return inner.get ();
+ }
+
+ public void set_value (V value) {
+ assert_not_reached ();
+ }
+
+ public bool mutable { get { return false; } }
+ }
+}
diff --git a/gee/abstractmultiset.vala b/gee/abstractmultiset.vala
new file mode 100644
index 0000000..4d2f781
--- /dev/null
+++ b/gee/abstractmultiset.vala
@@ -0,0 +1,180 @@
+/* abstractmultiset.vala
+ *
+ * Copyright (C) 2009 Ali Sabil
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Ali Sabil <ali sabil gmail com>
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Skeletal implementation of the {@link MultiSet} interface.
+ *
+ * @see HashMultiSet
+ * @see TreeMultiSet
+ */
+public abstract class Vala.AbstractMultiSet<G> : AbstractCollection<G>, MultiSet<G> {
+ public override int size {
+ get { return _nitems; }
+ }
+
+ public override bool read_only {
+ get { return false; }
+ }
+
+ protected Map<G, int> _storage_map;
+ private int _nitems = 0;
+
+ /**
+ * Constructs a new, empty abstract multi set.
+ */
+ public AbstractMultiSet (Map<G, int> storage_map) {
+ this._storage_map = storage_map;
+ }
+
+ public int count (G item) {
+ int result = 0;
+ if (_storage_map.has_key (item)) {
+ result = _storage_map.get (item);
+ }
+ return result;
+ }
+
+ public override bool contains (G item) {
+ return _storage_map.has_key (item);
+ }
+
+ public override Vala.Iterator<G> iterator () {
+ return new Iterator<G> (this);
+ }
+
+ public override bool add (G item) {
+ if (_storage_map.has_key (item)) {
+ int current_count = _storage_map.get (item);
+ _storage_map.set (item, current_count + 1);
+ } else {
+ _storage_map.set (item, 1);
+ }
+ _nitems++;
+ return true;
+ }
+
+ public override bool remove (G item) {
+ if (_nitems > 0 && _storage_map.has_key (item)) {
+ int current_count = _storage_map.get (item);
+ if (current_count <= 1) {
+ _storage_map.unset (item);
+ } else {
+ _storage_map.set (item, current_count - 1);
+ }
+ _nitems--;
+ return true;
+ }
+ return false;
+ }
+
+ public override void clear () {
+ _storage_map.clear ();
+ _nitems = 0;
+ }
+
+ private class Iterator<G> : Object, Traversable<G>, Vala.Iterator<G> {
+ private AbstractMultiSet<G> _set;
+
+ private MapIterator<G, int> _iter;
+ private int _pending = 0;
+ private bool _removed = false;
+
+ public Iterator (AbstractMultiSet<G> set) {
+ _set = set;
+ _iter = _set._storage_map.map_iterator ();
+ }
+
+ public bool next () {
+ _removed = false;
+ if (_pending == 0) {
+ if (_iter.next ()) {
+ _pending = _iter.get_value () - 1;
+ return true;
+ }
+ } else {
+ _pending--;
+ return true;
+ }
+ return false;
+ }
+
+ public bool has_next () {
+ return _pending > 0 || _iter.has_next ();
+ }
+
+ public new G get () {
+ assert (! _removed);
+ return _iter.get_key ();
+ }
+
+ public void remove () {
+ assert (! _removed);
+ _iter.set_value (_pending = _iter.get_value () - 1);
+ if (_pending == 0) {
+ _iter.unset ();
+ }
+ _set._nitems--;
+ _removed = true;
+ }
+
+ public bool read_only {
+ get {
+ return false;
+ }
+ }
+
+ public bool valid {
+ get {
+ return ! _removed && _iter.valid;
+ }
+ }
+
+ public bool foreach (ForallFunc<G> f) {
+ if (_iter.valid) {
+ if (!_removed) {
+ if (!f(_iter.get_key())) {
+ return false;
+ }
+ }
+ for(int i = _pending - 1; i >= 0; --i) {
+ if (!f(_iter.get_key())) {
+ _pending = i;
+ return false;
+ }
+ }
+ }
+ while(_iter.next()) {
+ for(int i = _iter.get_value() - 1; i >= 0; --i) {
+ if (!f(_iter.get_key())) {
+ _removed = false;
+ _pending = i;
+ return false;
+ }
+ }
+ }
+ _removed = false;
+ _pending = 0;
+ return true;
+ }
+ }
+}
diff --git a/gee/abstractqueue.vala b/gee/abstractqueue.vala
new file mode 100644
index 0000000..e364378
--- /dev/null
+++ b/gee/abstractqueue.vala
@@ -0,0 +1,55 @@
+/* abstractqueue.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Skeletal implementation of the {@link Queue} interface.
+ *
+ * Contains common code shared by all queue implementations.
+ *
+ * @see PriorityQueue
+ */
+public abstract class Vala.AbstractQueue<G> : Vala.AbstractCollection<G>, Queue<G> {
+ /**
+ * {@inheritDoc}
+ */
+ public abstract int capacity { get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract int remaining_capacity { get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract bool is_full { get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G? peek ();
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G? poll ();
+}
diff --git a/gee/abstractset.vala b/gee/abstractset.vala
new file mode 100644
index 0000000..71effc5
--- /dev/null
+++ b/gee/abstractset.vala
@@ -0,0 +1,50 @@
+/* abstractset.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Julien Peeters <contact julienpeeters fr>
+ */
+
+/**
+ * Skeletal implementation of the {@link Set} interface.
+ *
+ * Contains common code shared by all set implementations.
+ *
+ * @see HashSet
+ * @see TreeSet
+ */
+public abstract class Vala.AbstractSet<G> : Vala.AbstractCollection<G>, Set<G> {
+
+ private weak Set<G> _read_only_view;
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual new Set<G> read_only_view {
+ owned get {
+ Set<G> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlySet<G> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+}
diff --git a/gee/abstractsortedmap.vala b/gee/abstractsortedmap.vala
new file mode 100644
index 0000000..876a4c3
--- /dev/null
+++ b/gee/abstractsortedmap.vala
@@ -0,0 +1,65 @@
+/* readonlysortedmap.vala
+ *
+ * Copyright (C) 2009-2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+public abstract class Vala.AbstractSortedMap<K, V> : AbstractMap<K,V>, SortedMap<K,V> {
+ /**
+ * {@inheritDoc}
+ */
+ public abstract SortedMap<K,V> head_map (K before);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract SortedMap<K,V> tail_map (K after);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract SortedMap<K,V> sub_map (K before, K after);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract SortedSet<K> ascending_keys { owned get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract SortedSet<Map.Entry<K,V>> ascending_entries { owned get; }
+
+ private weak SortedMap<K,V> _read_only_view;
+ /**
+ * The read-only view this map.
+ */
+ public new SortedMap<K,V> read_only_view {
+ owned get {
+ SortedMap<K,V> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlySortedMap<K,V> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+}
+
diff --git a/gee/abstractsortedset.vala b/gee/abstractsortedset.vala
new file mode 100644
index 0000000..03f02f3
--- /dev/null
+++ b/gee/abstractsortedset.vala
@@ -0,0 +1,98 @@
+/* abstractsortedset.vala
+ *
+ * Copyright (C) 2009-2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Skeletal implementation of the {@link SortedSet} interface.
+ *
+ * Contains common code shared by all set implementations.
+ *
+ * @see TreeSet
+ */
+public abstract class Vala.AbstractSortedSet<G> : Vala.AbstractSet<G>, SortedSet<G> {
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G first ();
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G last ();
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract Iterator<G>? iterator_at (G element);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G? lower (G element);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G? higher (G element);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G? floor (G element);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract G? ceil (G element);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract SortedSet<G> head_set (G before);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract SortedSet<G> tail_set (G after);
+
+ /**
+ * {@inheritDoc}
+ */
+ public abstract SortedSet<G> sub_set (G from, G to);
+
+ private weak SortedSet<G> _read_only_view;
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual new SortedSet<G> read_only_view {
+ owned get {
+ SortedSet<G> instance = _read_only_view;
+ if (_read_only_view == null) {
+ instance = new ReadOnlySortedSet<G> (this);
+ _read_only_view = instance;
+ instance.add_weak_pointer ((void**) (&_read_only_view));
+ }
+ return instance;
+ }
+ }
+}
+
diff --git a/gee/arraylist.vala b/gee/arraylist.vala
index fe398e4..4bcb3e0 100644
--- a/gee/arraylist.vala
+++ b/gee/arraylist.vala
@@ -3,6 +3,7 @@
* Copyright (C) 2004-2005 Novell, Inc
* Copyright (C) 2005 David Waite
* Copyright (C) 2007-2008 Jürg Billeter
+ * Copyright (C) 2009 Didier Villevalois
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -20,66 +21,139 @@
*
* Author:
* Jürg Billeter <j bitron ch>
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
*/
using GLib;
/**
- * Arrays of arbitrary elements which grow automatically as elements are added.
+ * Resizable array implementation of the {@link List} interface.
+ *
+ * The storage array grows automatically when needed.
+ *
+ * This implementation is pretty good for rarely modified data. Because they are
+ * stored in an array this structure does not fit for highly mutable data. For an
+ * alternative implementation see {@link LinkedList}.
+ *
+ * @see LinkedList
*/
-public class Vala.ArrayList<G> : List<G> {
+public class Vala.ArrayList<G> : AbstractBidirList<G> {
+ /**
+ * {@inheritDoc}
+ */
public override int size {
get { return _size; }
}
- public EqualFunc<G> equal_func {
- set { _equal_func = value; }
+ /**
+ * {@inheritDoc}
+ */
+ public override bool read_only {
+ get { return false; }
}
- private G[] _items = new G[4];
- private int _size;
- private EqualFunc<G> _equal_func;
+ /**
+ * The elements' equality testing function.
+ */
+ [CCode (notify = false)]
+ public EqualDataFunc<G> equal_func { private set; get; }
+
+ internal G[] _items = new G[4];
+ internal int _size;
// concurrent modification protection
private int _stamp = 0;
- public ArrayList (EqualFunc<G> equal_func = GLib.direct_equal) {
+ /**
+ * Constructs a new, empty array list.
+ *
+ * If not provided, the function parameter is requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param equal_func an optional element equality testing function
+ */
+ public ArrayList (owned EqualDataFunc<G>? equal_func = null) {
+ if (equal_func == null) {
+ equal_func = Functions.get_equal_func_for (typeof (G));
+ }
this.equal_func = equal_func;
}
- public override Type get_element_type () {
- return typeof (G);
+ /**
+ * {@inheritDoc}
+ */
+ public override bool foreach(ForallFunc<G> f) {
+ for (int i = 0; i < _size; i++) {
+ if (!f (_items[i])) {
+ return false;
+ }
+ }
+ return true;
}
+ /**
+ * {@inheritDoc}
+ */
public override Vala.Iterator<G> iterator () {
return new Iterator<G> (this);
}
+ /**
+ * {@inheritDoc}
+ */
+ public override ListIterator<G> list_iterator () {
+ return new Iterator<G> (this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override BidirListIterator<G> bidir_list_iterator () {
+ return new Iterator<G> (this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
public override bool contains (G item) {
return (index_of (item) != -1);
}
+ /**
+ * {@inheritDoc}
+ */
public override int index_of (G item) {
for (int index = 0; index < _size; index++) {
- if (_equal_func (_items[index], item)) {
+ if (equal_func (_items[index], item)) {
return index;
}
}
return -1;
}
- public override G? get (int index) {
- assert (index >= 0 && index < _size);
+ /**
+ * {@inheritDoc}
+ */
+ public override G get (int index) {
+ assert (index >= 0);
+ assert (index < _size);
return _items[index];
}
+ /**
+ * {@inheritDoc}
+ */
public override void set (int index, G item) {
- assert (index >= 0 && index < _size);
+ assert (index >= 0);
+ assert (index < _size);
_items[index] = item;
}
+ /**
+ * {@inheritDoc}
+ */
public override bool add (G item) {
if (_size == _items.length) {
grow_if_needed (1);
@@ -89,8 +163,12 @@ public class Vala.ArrayList<G> : List<G> {
return true;
}
+ /**
+ * {@inheritDoc}
+ */
public override void insert (int index, G item) {
- assert (index >= 0 && index <= _size);
+ assert (index >= 0);
+ assert (index <= _size);
if (_size == _items.length) {
grow_if_needed (1);
@@ -100,9 +178,12 @@ public class Vala.ArrayList<G> : List<G> {
_stamp++;
}
+ /**
+ * {@inheritDoc}
+ */
public override bool remove (G item) {
for (int index = 0; index < _size; index++) {
- if (_equal_func (_items[index], item)) {
+ if (equal_func (_items[index], item)) {
remove_at (index);
return true;
}
@@ -110,16 +191,25 @@ public class Vala.ArrayList<G> : List<G> {
return false;
}
- public override void remove_at (int index) {
- assert (index >= 0 && index < _size);
+ /**
+ * {@inheritDoc}
+ */
+ public override G remove_at (int index) {
+ assert (index >= 0);
+ assert (index < _size);
+ G item = _items[index];
_items[index] = null;
shift (index + 1, -1);
_stamp++;
+ return item;
}
+ /**
+ * {@inheritDoc}
+ */
public override void clear () {
for (int index = 0; index < _size; index++) {
_items[index] = null;
@@ -128,8 +218,40 @@ public class Vala.ArrayList<G> : List<G> {
_stamp++;
}
+ /**
+ * {@inheritDoc}
+ */
+ public override List<G>? slice (int start, int stop) {
+ return_val_if_fail (start <= stop, null);
+ return_val_if_fail (start >= 0, null);
+ return_val_if_fail (stop <= _size, null);
+
+ var slice = new ArrayList<G> (this.equal_func);
+ for (int i = start; i < stop; i++) {
+ slice.add (this[i]);
+ }
+
+ return slice;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool add_all (Collection<G> collection) {
+ if (collection.is_empty) {
+ return false;
+ }
+
+ grow_if_needed (collection.size);
+ collection.foreach ((item) => {_items[_size++] = item; return true;});
+ _stamp++;
+ return true;
+ }
+
private void shift (int start, int delta) {
- assert (start >= 0 && start <= _size && start >= -delta);
+ assert (start >= 0);
+ assert (start <= _size);
+ assert (start >= -delta);
_items.move (start, start + delta, _size - start);
@@ -152,40 +274,144 @@ public class Vala.ArrayList<G> : List<G> {
_items.resize (value);
}
- private class Iterator<G> : Vala.Iterator<G> {
- public ArrayList<G> list {
- set {
- _list = value;
- _stamp = _list._stamp;
- }
- }
-
+ private class Iterator<G> : Object, Traversable<G>, Vala.Iterator<G>, BidirIterator<G>,
ListIterator<G>, BidirListIterator<G> {
private ArrayList<G> _list;
private int _index = -1;
+ private bool _removed = false;
// concurrent modification protection
- public int _stamp = 0;
+ private int _stamp = 0;
public Iterator (ArrayList list) {
- this.list = list;
+ _list = list;
+ _stamp = _list._stamp;
}
- public override bool next () {
+ public bool next () {
assert (_stamp == _list._stamp);
- if (_index < _list._size) {
+ if (_index + 1 < _list._size) {
_index++;
+ _removed = false;
+ return true;
+ }
+ return false;
+ }
+
+ public bool has_next () {
+ assert (_stamp == _list._stamp);
+ return (_index + 1 < _list._size);
+ }
+
+ public bool first () {
+ assert (_stamp == _list._stamp);
+ if (_list.size == 0) {
+ return false;
+ }
+ _index = 0;
+ _removed = false;
+ return true;
+ }
+
+ public new G get () {
+ assert (_stamp == _list._stamp);
+ assert (_index >= 0);
+ assert (_index < _list._size);
+ assert (! _removed);
+ return _list._items[_index];
+ }
+
+ public void remove () {
+ assert (_stamp == _list._stamp);
+ assert (_index >= 0);
+ assert (_index < _list._size);
+ assert (! _removed);
+ _list.remove_at (_index);
+ _index--;
+ _removed = true;
+ _stamp = _list._stamp;
+ }
+
+ public bool previous () {
+ assert (_stamp == _list._stamp);
+ if (_index > 0) {
+ _index--;
+ return true;
}
- return (_index < _list._size);
+ return false;
+ }
+
+ public bool has_previous () {
+ assert (_stamp == _list._stamp);
+ return (_index - 1 >= 0);
+ }
+
+ public bool last () {
+ assert (_stamp == _list._stamp);
+ if (_list.size == 0) {
+ return false;
+ }
+ _index = _list._size - 1;
+ return true;
+ }
+
+ public new void set (G item) {
+ assert (_stamp == _list._stamp);
+ assert (_index >= 0);
+ assert (_index < _list._size);
+ _list._items[_index] = item;
+ _stamp = ++_list._stamp;
+ }
+
+ public void insert (G item) {
+ assert (_stamp == _list._stamp);
+ assert (_index >= 0);
+ assert (_index < _list._size);
+ _list.insert (_index, item);
+ _index++;
+ _stamp = _list._stamp;
}
- public override G? get () {
+ public void add (G item) {
assert (_stamp == _list._stamp);
+ assert (_index >= 0);
+ assert (_index < _list._size);
+ _list.insert (_index + 1, item);
+ _index++;
+ _stamp = _list._stamp;
+ }
+
+ public int index () {
+ assert (_stamp == _list._stamp);
+ assert (_index >= 0);
+ assert (_index < _list._size);
+ return _index;
+ }
- if (_index < 0 || _index >= _list._size) {
- return null;
+ public bool read_only {
+ get {
+ return false;
}
+ }
- return _list.get (_index);
+ public bool valid {
+ get {
+ return _index >= 0 && _index < _list._size && ! _removed;
+ }
+ }
+
+ public bool foreach (ForallFunc<G> f) {
+ assert (_stamp == _list._stamp);
+ if (_index < 0 || _removed) {
+ _index++;
+ }
+ while (_index < _list._size) {
+ if (!f (_list._items[_index])) {
+ return false;
+ }
+ _index++;
+ }
+ _index = _list._size - 1;
+ return true;
}
}
}
diff --git a/gee/arrayqueue.vala b/gee/arrayqueue.vala
new file mode 100644
index 0000000..9eac3e6
--- /dev/null
+++ b/gee/arrayqueue.vala
@@ -0,0 +1,342 @@
+/* arrayqueue.vala
+ *
+ * Copyright (C) 2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Resizable array implementation of the {@link Deque} interface.
+ *
+ * The storage array grows automatically when needed.
+ *
+ * This implementation is pretty good for lookups at the end or random.
+ * Because they are stored in an array this structure does not fit for deleting
+ * arbitrary elements. For an alternative implementation see {@link LinkedList}.
+ *
+ * @see LinkedList
+ */
+public class Vala.ArrayQueue<G> : Vala.AbstractQueue<G>, Deque<G> {
+ /**
+ * Constructs a new, empty array queue.
+ *
+ * If not provided, the function parameter is requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param equal_func an optional element equality testing function
+ */
+ public ArrayQueue (owned EqualDataFunc<G>? equal_func = null) {
+ if (equal_func == null) {
+ equal_func = Functions.get_equal_func_for (typeof (G));
+ }
+ this.equal_func = equal_func;
+ this._items = new G[10];
+ }
+
+ [CCode (notify = false)]
+ public EqualDataFunc<G> equal_func { private set; get; }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int size { get { return _length; } }
+
+ public bool is_empty { get { return _length == 0; } }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool read_only { get { return false; } }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int capacity { get {return Queue.UNBOUNDED_CAPACITY;} }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int remaining_capacity { get {return Queue.UNBOUNDED_CAPACITY;} }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool is_full { get { return false; } }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.Iterator<G> iterator() {
+ return new Iterator<G> (this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool add (G element) {
+ return offer_tail (element);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool contains (G item) {
+ return find_index(item) != -1;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool remove (G item) {
+ _stamp++;
+ int index = find_index (item);
+ if (index == -1) {
+ return false;
+ } else {
+ remove_at (index);
+ return true;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void clear() {
+ _stamp++;
+ for (int i = 0; i < _length; i++) {
+ _items[(_start + i) % _items.length] = null;
+ }
+ _start = _length = 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? peek () {
+ return peek_head ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? poll () {
+ return poll_head ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool offer_head (G element) {
+ grow_if_needed ();
+ _start = (_items.length + _start - 1) % _items.length;
+ _length++;
+ _items[_start] = element;
+ _stamp++;
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? peek_head () {
+ return _items[_start];
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? poll_head () {
+ _stamp++;
+ if (_length == 0) {
+ _start = 0;
+ return null;
+ } else {
+ _length--;
+ G result = (owned)_items[_start];
+ _start = (_start + 1) % _items.length;
+ return (owned)result;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int drain_head (Collection<G> recipient, int amount = -1) {
+ return drain (recipient, amount);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool offer_tail (G element) {
+ grow_if_needed();
+ _items[(_start + _length++) % _items.length] = element;
+ _stamp++;
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? peek_tail () {
+ return _items[(_items.length + _start + _length - 1) % _items.length];
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? poll_tail () {
+ _stamp++;
+ if (_length == 0) {
+ _start = 0;
+ return null;
+ } else {
+ return (owned)_items[(_items.length + _start + --_length) % _items.length];
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int drain_tail (Collection<G> recipient, int amount = -1) {
+ G? item = null;
+ int drained = 0;
+ while((amount == -1 || --amount >= 0) && (item = poll_tail ()) != null) {
+ recipient.add(item);
+ drained++;
+ }
+ return drained;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ private void grow_if_needed () {
+ if (_items.length < _length +1 ) {
+ _items.resize (2 * _items.length);
+#if 0
+ _items.move (0, _length, _start);
+#else
+ // See bug #667452
+ for(int i = 0; i < _start; i++)
+ _items[_length + i] = (owned)_items[i];
+#endif
+ }
+ }
+
+ private int find_index (G item) {
+ for (int i = _start; i < int.min(_items.length, _start + _length); i++) {
+ if (equal_func(item, _items[i])) {
+ return i;
+ }
+ }
+ for (int i = 0; i < _start + _length - _items.length; i++) {
+ if (equal_func(item, _items[i])) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ private void remove_at (int index) {
+ int end = (_items.length + _start + _length - 1) % _items.length + 1;
+ if (index == _start) {
+ _items[_start++] = null;
+ _length--;
+ return;
+ } else if (index > _start && end <= _start) {
+ _items[index] = null;
+ _items.move (index + 1, index, _items.length - 1);
+ _items[_items.length - 1] = (owned)_items[0];
+ _items.move (1, 0, end - 1);
+ _length--;
+ } else {
+ _items[index] = null;
+ _items.move (index + 1, index, end - (index + 1));
+ _length--;
+ }
+ }
+
+ private class Iterator<G> : GLib.Object, Traversable<G>, Vala.Iterator<G> {
+ public Iterator (ArrayQueue<G> queue) {
+ _queue = queue;
+ _stamp = _queue._stamp;
+ }
+
+ public bool next () {
+ assert (_queue._stamp == _stamp);
+ if (has_next ()) {
+ _offset++;
+ _removed = false;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public bool has_next () {
+ assert (_queue._stamp == _stamp);
+ return _offset + 1 < _queue._length;
+ }
+
+ public new G get () {
+ assert (_queue._stamp == _stamp);
+ assert (_offset != -1);
+ assert (!_removed);
+ return _queue._items[(_queue._start + _offset) % _queue._items.length];
+ }
+
+ public void remove () {
+ assert (_queue._stamp++ == _stamp++);
+ _queue.remove_at((_queue._start + _offset) % _queue._items.length);
+ _offset--;
+ _removed = true;
+ }
+
+ public bool valid { get {return _offset != -1 && !_removed;} }
+
+ public bool read_only { get {return false;} }
+
+ public bool foreach (ForallFunc<G> f) {
+ assert (_queue._stamp == _stamp);
+ if (!valid) {
+ _offset++;
+ _removed = false;
+ }
+ for (int i = _offset; i < _queue._length; i++) {
+ if (!f (_queue._items[(_queue._start + i) % _queue._items.length])) {
+ _offset = i;
+ return false;
+ }
+ }
+ _offset = _queue._length - 1;
+ return true;
+ }
+
+ private ArrayQueue _queue;
+ private int _stamp;
+ private int _offset = -1;
+ private bool _removed = false;
+ }
+
+ private G[] _items;
+ private int _start = 0;
+ private int _length = 0;
+ private int _stamp = 0;
+}
+
diff --git a/gee/bidiriterator.vala b/gee/bidiriterator.vala
new file mode 100644
index 0000000..01d3af2
--- /dev/null
+++ b/gee/bidiriterator.vala
@@ -0,0 +1,55 @@
+/* bidiriterator.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois, Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * A bi-directional iterator.
+ */
+[GenericAccessors]
+public interface Vala.BidirIterator<G> : Vala.Iterator<G> {
+ /**
+ * Rewinds to the previous element in the iteration.
+ *
+ * @return ``true`` if the iterator has a previous element
+ */
+ public abstract bool previous ();
+
+ /**
+ * Checks whether there is a previous element in the iteration.
+ *
+ * @return ``true`` if the iterator has a previous element
+ */
+ public abstract bool has_previous ();
+
+ /**
+ * Rewinds to the first element in the iteration.
+ *
+ * @return ``true`` if the iterator has a first element
+ */
+ public abstract bool first ();
+
+ /**
+ * Advances to the last element in the iteration.
+ *
+ * @return ``true`` if the iterator has a last element
+ */
+ public abstract bool last ();
+}
diff --git a/gee/bidirlist.vala b/gee/bidirlist.vala
new file mode 100644
index 0000000..f482adf
--- /dev/null
+++ b/gee/bidirlist.vala
@@ -0,0 +1,35 @@
+/* bidirlist.vala
+ *
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+[GenericAccessors]
+public interface Vala.BidirList<G> : Vala.List<G> {
+ /**
+ * Returns a BidirListIterator that can be used for iteration over this list.
+ *
+ * @return a BidirListIterator that can be used for iteration over this list
+ */
+ public abstract new BidirListIterator<G> bidir_list_iterator ();
+
+ /**
+ * The read-only view of this list.
+ */
+ public abstract new BidirList<G> read_only_view { owned get; }
+}
diff --git a/gee/bidirlistiterator.vala b/gee/bidirlistiterator.vala
new file mode 100644
index 0000000..094a5f7
--- /dev/null
+++ b/gee/bidirlistiterator.vala
@@ -0,0 +1,30 @@
+/* bidirlistiterator.vala
+ *
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+[GenericAccessors]
+public interface Vala.BidirListIterator<G> : Vala.BidirIterator<G>, Vala.ListIterator<G> {
+ /**
+ * Inserts the specified item before the current item in the iteration. The
+ * cursor is let to point to the current item.
+ */
+ public abstract void insert (G item);
+}
+
diff --git a/gee/bidirmapiterator.vala b/gee/bidirmapiterator.vala
new file mode 100644
index 0000000..32e2e6b
--- /dev/null
+++ b/gee/bidirmapiterator.vala
@@ -0,0 +1,56 @@
+/* bidiriterator.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois, Maciej Piechotka
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * A bi-directional Map iterator.
+ */
+[GenericAccessors]
+public interface Vala.BidirMapIterator<K,V> : Vala.MapIterator<K,V> {
+ /**
+ * Rewinds to the previous element in the iteration.
+ *
+ * @return `true` if the iterator has a previous element
+ */
+ public abstract bool previous ();
+
+ /**
+ * Checks whether there is a previous element in the iteration.
+ *
+ * @return `true` if the iterator has a previous element
+ */
+ public abstract bool has_previous ();
+
+ /**
+ * Goes back to the first element.
+ *
+ * @return `true` if the iterator has a first element
+ */
+ public abstract bool first ();
+
+ /**
+ * Advances to the last element in the iteration.
+ *
+ * @return `true` if the iterator has a last element
+ */
+ public abstract bool last ();
+}
diff --git a/gee/bidirsortedmap.vala b/gee/bidirsortedmap.vala
new file mode 100644
index 0000000..1a70576
--- /dev/null
+++ b/gee/bidirsortedmap.vala
@@ -0,0 +1,45 @@
+/* bidirsortedmap.vala
+ *
+ * Copyright (C) 2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+[GenericAccessors]
+public interface Vala.BidirSortedMap<K,V> : SortedMap<K,V> {
+ /**
+ * Returns a bi-directional iterator for this map.
+ *
+ * @return a bi-directional map iterator
+ */
+ public abstract BidirMapIterator<K,V> bidir_map_iterator ();
+
+ /**
+ * The read-only view of this set.
+ */
+ public abstract new BidirSortedMap<K,V> read_only_view { owned get; }
+
+ /**
+ * Returns an immutable empty sorted set.
+ *
+ * @return an immutable empty sorted set
+ */
+ public static BidirSortedMap<K,V> empty<K,V> () {
+ return new TreeMap<K,V> ().read_only_view;
+ }
+}
+
diff --git a/gee/bidirsortedset.vala b/gee/bidirsortedset.vala
new file mode 100644
index 0000000..b22172d
--- /dev/null
+++ b/gee/bidirsortedset.vala
@@ -0,0 +1,46 @@
+/* bidirsortedset.vala
+ *
+ * Copyright (C) 2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+[GenericAccessors]
+public interface Vala.BidirSortedSet<G> : SortedSet<G> {
+ /**
+ * Returns a {@link BidirIterator} that can be used for bi-directional
+ * iteration over this sorted set.
+ *
+ * @return a {@link BidirIterator} over this sorted set
+ */
+ public abstract BidirIterator<G> bidir_iterator ();
+
+ /**
+ * The read-only view of this set.
+ */
+ public abstract new BidirSortedSet<G> read_only_view { owned get; }
+
+ /**
+ * Returns an immutable empty sorted set.
+ *
+ * @return an immutable empty sorted set
+ */
+ public static BidirSortedSet<G> empty<G> () {
+ return new TreeSet<G> ().read_only_view;
+ }
+}
+
diff --git a/gee/collection.vala b/gee/collection.vala
index 76f568a..112e6ac 100644
--- a/gee/collection.vala
+++ b/gee/collection.vala
@@ -1,6 +1,6 @@
/* collection.vala
*
- * Copyright (C) 2007 Jürg Billeter
+ * Copyright (C) 2007-2009 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -21,21 +21,32 @@
*/
/**
- * Serves as the base interface for implementing collection classes. Defines
- * size, iteration, and modification methods.
+ * A generic collection of objects.
*/
-public abstract class Vala.Collection<G> : Iterable<G> {
+[GenericAccessors]
+public interface Vala.Collection<G> : Iterable<G> {
/**
* The number of items in this collection.
*/
public abstract int size { get; }
/**
+ * Specifies whether this collection is empty.
+ */
+ public virtual bool is_empty { get { return size == 0; } }
+
+ /**
+ * Specifies whether this collection can change - i.e. wheather {@link add},
+ * {@link remove} etc. are legal operations.
+ */
+ public abstract bool read_only { get; }
+
+ /**
* Determines whether this collection contains the specified item.
*
* @param item the item to locate in the collection
*
- * @return true if item is found, false otherwise
+ * @return ``true`` if item is found, ``false`` otherwise
*/
public abstract bool contains (G item);
@@ -45,17 +56,17 @@ public abstract class Vala.Collection<G> : Iterable<G> {
*
* @param item the item to add to the collection
*
- * @return true if the collection has been changed, false otherwise
+ * @return ``true`` if the collection has been changed, ``false`` otherwise
*/
public abstract bool add (G item);
/**
- * Removes the first occurrence of an item from this collection. Must not
+ * Removes the first occurence of an item from this collection. Must not
* be called on read-only collections.
*
* @param item the item to remove from the collection
*
- * @return true if the collection has been changed, false otherwise
+ * @return ``true`` if the collection has been changed, ``false`` otherwise
*/
public abstract bool remove (G item);
@@ -64,5 +75,219 @@ public abstract class Vala.Collection<G> : Iterable<G> {
* read-only collections.
*/
public abstract void clear ();
+
+ /**
+ * Adds all items in the input collection to this collection.
+ *
+ * @param collection the collection which items will be added to this
+ * collection.
+ *
+ * @return ``true`` if the collection has been changed, ``false`` otherwise
+ */
+ public virtual bool add_all (Collection<G> collection) {
+ return collection.fold<bool> ((item, changed) => changed | add (item), false);
+ }
+
+ /**
+ * Returns ``true`` it this collection contains all items as the input
+ * collection.
+ *
+ * @param collection the collection which items will be compared with
+ * this collection.
+ *
+ * @return ``true`` if the collection has been changed, ``false`` otherwise
+ */
+ public virtual bool contains_all (Collection<G> collection) {
+ return collection.foreach ((item) => contains (item));
+ }
+
+ /**
+ * Removes the subset of items in this collection corresponding to the
+ * elments in the input collection. If there is several occurrences of
+ * the same value in this collection they are decremented of the number
+ * of occurrences in the input collection.
+ *
+ * @param collection the collection which items will be compared with
+ * this collection.
+ *
+ * @return ``true`` if the collection has been changed, ``false`` otherwise
+ */
+ public virtual bool remove_all (Collection<G> collection) {
+ return collection.fold<bool> ((item, changed) => changed | remove (item), false);
+ }
+
+ /**
+ * Removes all items in this collection that are not contained in the input
+ * collection. In other words all common items of both collections are
+ * retained in this collection.
+ *
+ * @param collection the collection which items will be compared with
+ * this collection.
+ *
+ * @return ``true`` if the collection has been changed, ``false`` otherwise
+ */
+ public virtual bool retain_all (Collection<G> collection) {
+ bool changed = false;
+ for (Iterator<G> iter = iterator(); iter.next ();) {
+ G item = iter.get ();
+ if (!collection.contains (item)) {
+ iter.remove ();
+ changed = true;
+ }
+ }
+ return changed;
+ }
+
+ /**
+ * Returns an array containing all of items from this collection.
+ *
+ * @return an array containing all of items from this collection
+ */
+ public virtual G[] to_array () {
+ var t = typeof (G);
+ if (t == typeof (bool)) {
+ return (G[]) to_bool_array ((Collection<bool>) this);
+ } else if (t == typeof (char)) {
+ return (G[]) to_char_array ((Collection<char>) this);
+ } else if (t == typeof (uchar)) {
+ return (G[]) to_uchar_array ((Collection<uchar>) this);
+ } else if (t == typeof (int)) {
+ return (G[]) to_int_array ((Collection<int>) this);
+ } else if (t == typeof (uint)) {
+ return (G[]) to_uint_array ((Collection<uint>) this);
+ } else if (t == typeof (int64)) {
+ return (G[]) to_int64_array ((Collection<int64>) this);
+ } else if (t == typeof (uint64)) {
+ return (G[]) to_uint64_array ((Collection<uint64>) this);
+ } else if (t == typeof (long)) {
+ return (G[]) to_long_array ((Collection<long>) this);
+ } else if (t == typeof (ulong)) {
+ return (G[]) to_ulong_array ((Collection<ulong>) this);
+ } else if (t == typeof (float)) {
+ return (G[]) to_float_array ((Collection<float>) this);
+ } else if (t == typeof (double)) {
+ return (G[]) to_double_array ((Collection<double>) this);
+ } else {
+ G[] array = new G[size];
+ int index = 0;
+ foreach (G element in this) {
+ array[index++] = element;
+ }
+ return array;
+ }
+ }
+
+ private static bool[] to_bool_array (Collection<bool> coll) {
+ bool[] array = new bool[coll.size];
+ int index = 0;
+ foreach (bool element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static char[] to_char_array (Collection<char> coll) {
+ char[] array = new char[coll.size];
+ int index = 0;
+ foreach (char element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static uchar[] to_uchar_array (Collection<uchar> coll) {
+ uchar[] array = new uchar[coll.size];
+ int index = 0;
+ foreach (uchar element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static int[] to_int_array (Collection<int> coll) {
+ int[] array = new int[coll.size];
+ int index = 0;
+ foreach (int element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static uint[] to_uint_array (Collection<uint> coll) {
+ uint[] array = new uint[coll.size];
+ int index = 0;
+ foreach (uint element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static int64[] to_int64_array (Collection<int64?> coll) {
+ int64[] array = new int64[coll.size];
+ int index = 0;
+ foreach (int64 element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static uint64[] to_uint64_array (Collection<uint64?> coll) {
+ uint64[] array = new uint64[coll.size];
+ int index = 0;
+ foreach (uint64 element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static long[] to_long_array (Collection<long> coll) {
+ long[] array = new long[coll.size];
+ int index = 0;
+ foreach (long element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static ulong[] to_ulong_array (Collection<ulong> coll) {
+ ulong[] array = new ulong[coll.size];
+ int index = 0;
+ foreach (ulong element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static float?[] to_float_array (Collection<float?> coll) {
+ float?[] array = new float?[coll.size];
+ int index = 0;
+ foreach (float element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ private static double?[] to_double_array (Collection<double?> coll) {
+ double?[] array = new double?[coll.size];
+ int index = 0;
+ foreach (double element in coll) {
+ array[index++] = element;
+ }
+ return array;
+ }
+
+ /**
+ * The read-only view of this collection.
+ */
+ public abstract Collection<G> read_only_view { owned get; }
+
+ /**
+ * Returns an immutable empty collection.
+ *
+ * @return an immutable empty collection
+ */
+ public static Collection<G> empty<G> () {
+ return new HashSet<G> ().read_only_view;
+ }
}
diff --git a/gee/comparable.vala b/gee/comparable.vala
new file mode 100644
index 0000000..489a7c8
--- /dev/null
+++ b/gee/comparable.vala
@@ -0,0 +1,37 @@
+/* comparable.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * This interface defines a total ordering among instances of each class
+ * implementing it.
+ *
+ * @see Hashable
+ */
+public interface Vala.Comparable<G> : Object {
+ /**
+ * Compares this object with the specifed object.
+ *
+ * @return a negative integer, zero, or a positive integer as this object
+ * is less than, equal to, or greater than the specified object
+ */
+ public abstract int compare_to (G object);
+}
diff --git a/gee/concurrentlist.vala b/gee/concurrentlist.vala
new file mode 100644
index 0000000..485e2d2
--- /dev/null
+++ b/gee/concurrentlist.vala
@@ -0,0 +1,587 @@
+/* concurrentlist.vala
+ *
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * A single-linked list. This implementation is based on
+ * [[http://www.cse.yorku.ca/~ruppert/papers/lfll.pdf|Mikhail Fomitchev and Eric Ruppert paper ]].
+ *
+ * Many threads are allowed to operate on the same structure as well as modification
+ * of structure during iteration is allowed. However the change may not be immidiatly
+ * visible to other threads.
+ */
+public class Vala.ConcurrentList<G> : AbstractList<G> {
+ /**
+ * The elements' equality testing function.
+ */
+ [CCode (notify = false)]
+ public Vala.EqualDataFunc<G> equal_func { private set; get; }
+
+ /**
+ * Construct new, empty single linked list
+ *
+ * If not provided, the function parameter is requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param equal_func an optional element equality testing function
+ */
+ public ConcurrentList (owned Vala.EqualDataFunc<G>? equal_func = null) {
+ if (equal_func == null)
+ equal_func = Vala.Functions.get_equal_func_for (typeof (G));
+ this.equal_func = (owned)equal_func;
+ _head = new Node<G>.head ();
+ HazardPointer.set_pointer<Node<G>> (&_tail, _head);
+ }
+
+ ~ConcurrentList () {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ _head = null;
+ HazardPointer.set_pointer<Node<G>?> (&_tail, null);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool read_only {
+ get {
+ return false;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int size {
+ get {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ int result = 0;
+ for (var iter = iterator (); iter.next ();)
+ result++;
+ return result;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool is_empty {
+ get {
+ return !iterator ().next ();
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool contains (G item) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ for (var iter = iterator (); iter.next ();)
+ if (equal_func (item, iter.get ()))
+ return true;
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool add (G item) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ Node<G> node = new Node<G> (item);
+ node.insert (get_tail (), null);
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool remove (G item) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ Vala.Iterator<G> iter = iterator ();
+ while (iter.next ()) {
+ if (equal_func (item, iter.get ())) {
+ iter.remove ();
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void clear () {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ var iter = iterator ();
+ while (iter.next ())
+ iter.remove ();
+ HazardPointer.set_pointer (&_tail, _head);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.Iterator<G> iterator () {
+ return new Iterator<G> (_head);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override ListIterator<G> list_iterator () {
+ return new Iterator<G> (_head);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? get (int index) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ assert (index >= 0);
+ for (var iterator = iterator (); iterator.next ();)
+ if (index-- == 0)
+ return iterator.get ();
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void set (int index, G item) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ assert (index >= 0);
+ for (var iterator = list_iterator (); iterator.next ();) {
+ if (index-- == 0) {
+ iterator.set (item);
+ return;
+ }
+ }
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int index_of (G item) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ int index = 0;
+ for (var iterator = list_iterator (); iterator.next (); index++)
+ if (equal_func (item, iterator.get ()))
+ return index;
+ return -1;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void insert (int index, G item) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ assert (index >= 0);
+ if (index == 0) {
+ var prev = _head;
+ var next = _head.get_next ();
+ Node<G> new_node = new Node<G> (item);
+ new_node.insert (prev, next);
+ } else {
+ for (var iterator = list_iterator (); iterator.next ();) {
+ if (--index == 0) {
+ iterator.add (item);
+ return;
+ }
+ }
+ assert_not_reached ();
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G remove_at (int index) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ for (var iterator = list_iterator (); iterator.next ();) {
+ if (index-- == 0) {
+ G data = iterator.get ();
+ iterator.remove ();
+ return data;
+ }
+ }
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override List<G>? slice (int start, int end) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ assert (0 <= start);
+ assert (start <= end);
+ var list = new ConcurrentList<G> (equal_func);
+ var iterator = iterator ();
+ int idx = 0;
+ for (; iterator.next (); idx++)
+ if (idx >= start && idx < end)
+ list.add (iterator.get ());
+ else if (idx >= end)
+ break;
+ assert (idx >= end);
+ return list;
+ }
+
+ private inline Node<G> update_tail () {
+ Node<G> tail = HazardPointer.get_pointer (&_tail);
+ Node.backtrace<G> (ref tail);
+ Node.search_for<G> (null, ref tail);
+ HazardPointer.set_pointer<Node<G>> (&_tail, tail);
+ return tail;
+ }
+
+ private inline Node<G> get_tail () {
+ return update_tail ();
+ }
+
+ private Node<G> _head;
+ private Node<G> *_tail;
+
+ private class Iterator<G> : Object, Vala.Traversable<G>, Vala.Iterator<G>, ListIterator<G> {
+ public Iterator (Node<G> head) {
+ _started = false;
+ _removed = false;
+ _index = -1;
+ _prev = null;
+ _curr = head;
+ }
+
+ public bool next () {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ Node<G>? _old_prev = _removed ? _prev : null;
+ bool success = Node.proceed<G> (ref _prev, ref _curr);
+ if (success) {
+ if (_removed)
+ _prev = _old_prev;
+ _removed = false;
+ _started = true;
+ _index++;
+ }
+ return success;
+ }
+
+ public bool has_next () {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ Node<G>? prev = _prev;
+ Node<G>? curr = _curr;
+ return Node.proceed<G> (ref prev, ref curr);
+ }
+
+ public new G get () {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ assert (valid);
+ return HazardPointer.get_pointer<G> (&_curr._data);
+ }
+
+ public new void set (G item) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ assert (valid);
+#if DEBUG
+ G item_copy = item;
+ stderr.printf (" Setting data %p to %p\n", _curr, item_copy);
+ HazardPointer.set_pointer<G> (&_curr._data, (owned)item_copy);
+#else
+ HazardPointer.set_pointer<G> (&_curr._data, item);
+#endif
+ }
+
+ public void remove () {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ assert (valid);
+ _curr.remove (_prev);
+ _removed = true;
+ _index--;
+ }
+
+ public bool valid {
+ get { return _started && !_removed && _curr != null; }
+ }
+
+ public bool read_only { get { return false; } }
+
+ public int index() {
+ assert (valid);
+ return _index;
+ }
+
+ public void add (G item) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ assert (valid);
+ if (!Node.proceed<G> (ref _prev, ref _curr)) {
+ _prev = (owned)_curr;
+ _curr = null;
+ }
+ Node<G> new_node = new Node<G> (item);
+ new_node.insert (_prev, _curr);
+ _curr = (owned)new_node;
+ _index++;
+ }
+
+ public new bool foreach (ForallFunc<G> f) {
+ HazardPointer.Context ctx = new HazardPointer.Context ();
+ if (_started && !_removed) {
+ if (!f (HazardPointer.get_pointer<G> (&_curr._data))) {
+ return false;
+ }
+ }
+ Node<G>? _old_prev = _removed ? _prev : null;
+ while (Node.proceed<G> (ref _prev, ref _curr)) {
+ if (_removed)
+ _prev = _old_prev;
+ _removed = false;
+ _started = true;
+ _index++;
+ if (!f (HazardPointer.get_pointer<G> (&_curr._data))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private bool _started;
+ private bool _removed;
+ private int _index;
+ private Node<G> _prev;
+ private Node<G>? _curr;
+ }
+
+ private class Node<G> {
+ public inline Node (G data) {
+ AtomicPointer.set (&_succ, null);
+ AtomicPointer.set (&_backlink, null);
+ G data_copy = data;
+ G *data_ptr = (owned)data_copy;
+#if DEBUG
+ stderr.printf (" Creating node %p with data %p\n", this, data_ptr);
+#endif
+ AtomicPointer.set (&_data, (owned)data_ptr);
+ }
+
+ public inline Node.head () {
+ AtomicPointer.set (&_succ, null);
+ AtomicPointer.set (&_backlink, null);
+ AtomicPointer.set (&_data, null);
+#if DEBUG
+ stderr.printf (" Creating head node %p\n", this);
+#endif
+ }
+
+ inline ~Node () {
+ HazardPointer.set_pointer<Node<G>?> (&_succ, null, 3);
+ HazardPointer.set_pointer<Node<G>?> (&_backlink, null);
+#if DEBUG
+ HazardPointer<G?>? old_data = HazardPointer.exchange_hazard_pointer (&_data, null);
+ stderr.printf (" Freeing node %p (with data %p)\n", this, old_data != null ?
old_data.get() : null);
+ if (old_data != null) {
+ old_data.release (HazardPointer.get_destroy_notify<G?> ());
+ }
+#else
+ HazardPointer.set_pointer<G> (&_data, null);
+#endif
+ }
+
+ public static inline bool proceed<G> (ref Node<G>? prev, ref Node<G> curr, bool force =
false) {
+ Node<G>? next = curr.get_next ();
+ while (next != null) {
+ State next_state = next.get_state ();
+ State curr_state;
+ Node<G> curr_next = curr.get_succ (out curr_state);
+ if (next_state != State.MARKED || (curr_state == State.MARKED && curr_next ==
next))
+ break;
+ if (curr_next == next)
+ next.help_marked (curr);
+ next = curr_next;
+ }
+ bool success = next != null;
+ if (success || force) {
+ prev = (owned)curr;
+ curr = (owned)next;
+#if DEBUG
+ stderr.printf (" Procceed to %p (previous %p)\n", curr, prev);
+#endif
+ }
+ return success;
+ }
+
+ public static inline bool search_for<G> (Node<G>? goal, ref Node<G>? prev) {
+ Node<G>? curr = prev.get_next ();
+ while ((curr != goal || curr != null) && proceed<G> (ref prev, ref curr, true));
+ return curr == goal;
+ }
+
+ public inline bool remove (Node<G> prev_node) {
+#if DEBUG
+ stderr.printf (" Removing %p (previous %p)\n", this, prev_node);
+#endif
+ Node<G>? prev = prev_node;
+ bool result = try_flag (ref prev);
+ if (prev != null)
+ help_flagged (prev);
+ return result;
+ }
+
+ public inline void insert (owned Node<G> prev, Node<G>? next) {
+#if DEBUG
+ stderr.printf (" Inserting %p between %p and %p\n", this, prev, next);
+#endif
+ while (true) {
+ State prev_state;
+ Node<G>? prev_next = get_succ (out prev_state);
+ if (prev_state == State.FLAGGED) {
+ prev_next.help_flagged (prev);
+ } else {
+ set_succ (next, State.NONE);
+ bool result = prev.compare_and_exchange (next, State.NONE, this,
State.NONE);
+ if (result)
+ return;
+ prev_next = get_succ (out prev_state);
+ if (prev_state == State.FLAGGED)
+ prev_next.help_flagged (prev);
+ backtrace<G> (ref prev);
+ }
+ search_for<G> (next, ref prev);
+ }
+
+ }
+
+ public inline void help_flagged (Node<G> prev) {
+#if DEBUG
+ stderr.printf (" Help flagging %p (previous %p)\n", this, prev);
+#endif
+ set_backlink (prev);
+ if (get_state () != State.MARKED)
+ try_mark ();
+ help_marked (prev);
+ }
+
+ public inline void try_mark () {
+#if DEBUG
+ stderr.printf (" Try flagging %p\n", this);
+#endif
+ do {
+ Node<G>? next_node = get_next ();
+ bool result = compare_and_exchange (next_node, State.NONE, next_node,
State.MARKED);
+ if (!result) {
+ State state;
+ next_node = get_succ (out state);
+ if (state == State.FLAGGED)
+ help_flagged (next_node);
+ }
+ } while (get_state () != State.MARKED);
+ }
+
+ public inline void help_marked (Node<G> prev_node) {
+#if DEBUG
+ stderr.printf (" Help marking %p (previous %p)\n", this, prev_node);
+#endif
+ prev_node.compare_and_exchange (this, State.FLAGGED, get_next (), State.NONE);
+ }
+
+ public inline bool try_flag (ref Node<G>? prev_node) {
+#if DEBUG
+ stderr.printf (" Try flagging %p (previous %p)\n", this, prev_node);
+#endif
+ while (true) {
+ if (prev_node.compare_succ (this, State.FLAGGED))
+ return false;
+ bool result = prev_node.compare_and_exchange (this, State.NONE, this,
State.FLAGGED);
+ if (result)
+ return true;
+ State result_state;
+ Node<G>? result_node = prev_node.get_succ (out result_state);
+ if (result_node == this && result_state == State.FLAGGED)
+ return false;
+ backtrace<G> (ref prev_node);
+ if (!search_for<G> (this, ref prev_node)) {
+ prev_node = null;
+ return false;
+ }
+ }
+ }
+
+ public static inline void backtrace<G> (ref Node<G>? curr) {
+ while (curr.get_state () == State.MARKED)
+ curr = curr.get_backlink ();
+ }
+
+ public inline bool compare_and_exchange (Node<G>? old_node, State old_state, Node<G>?
new_node, State new_state) {
+#if DEBUG
+ bool b = HazardPointer.compare_and_exchange_pointer (&_succ, old_node, new_node, 3,
(size_t)old_state, (size_t)new_state);
+ stderr.printf (" Setting %p.succ to (%p, %s) if %p.succ is (%p, %s): %s\n",
this, new_node, new_state.to_string (), this, old_node, old_state.to_string (), b ? "success" : "failure");
+ return b;
+#else
+ return HazardPointer.compare_and_exchange_pointer<Node<G>> (&_succ, old_node,
new_node, 3, (size_t)old_state, (size_t)new_state);
+#endif
+ }
+
+ public inline bool compare_succ (Node<G>? next, State state) {
+ size_t cur = (size_t)AtomicPointer.get (&_succ);
+ return cur == ((size_t)next | (size_t)state);
+ }
+
+ public inline Node<G>? get_next () {
+ return get_succ (null);
+ }
+
+ public inline State get_state () {
+ return (State)((size_t)AtomicPointer.get (&_succ) & 3);
+ }
+
+ public inline Node<G>? get_succ (out State state) {
+ size_t rstate;
+ Node<G>? succ = HazardPointer.get_pointer<Node<G>> (&_succ, 3, out rstate);
+ state = (State)rstate;
+ return (owned)succ;
+ }
+
+ public inline void set_succ (Node<G>? next, State state) {
+#if DEBUG
+ stderr.printf (" Setting %p.succ to (%p, %s)\n", this, next, state.to_string ());
+#endif
+ HazardPointer.set_pointer<Node<G>> (&_succ, next, 3, (size_t)state);
+ }
+
+ public inline Node<G>? get_backlink () {
+ return HazardPointer.get_pointer<Node<G>> (&_backlink);
+ }
+
+ public inline void set_backlink (Node<G>? backlink) {
+#if DEBUG
+ stderr.printf (" Setting backlink from %p to %p\n", this, backlink);
+#endif
+ HazardPointer.compare_and_exchange_pointer<Node<G>?> (&_backlink, null, backlink);
+ }
+
+ public Node<G> *_succ;
+ public Node<G> *_backlink;
+ public G *_data;
+ }
+
+ private enum State {
+ NONE = 0,
+ MARKED = 1,
+ FLAGGED = 2
+ }
+}
diff --git a/gee/deque.vala b/gee/deque.vala
new file mode 100644
index 0000000..f2ae3e1
--- /dev/null
+++ b/gee/deque.vala
@@ -0,0 +1,123 @@
+/* deque.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * A double-ended queue.
+ *
+ * A deque can be used either as a queue (First-In-First-Out behavior) or as a
+ * stack (Last-In-First-Out behavior).
+ *
+ * The methods defined by this interface behaves exactely in the same way as
+ * the {@link Queue} methods with respect to capacity bounds.
+ *
+ * The Deque interface inherits from the {@link Queue} interface. Thus, to use
+ * a deque as a queue, you can equivalently use the folowing method set:
+ *
+ * ||<)(> ''Queue method'' ||<)(> ''Deque method'' ||
+ * || {@link Queue.offer} || {@link offer_tail} ||
+ * || {@link Queue.peek} || {@link peek_head} ||
+ * || {@link Queue.poll} || {@link poll_head} ||
+ * || {@link Queue.drain} || {@link drain_head} ||
+ *
+ * To use a deque as a stack, just use the method set that acts at the head of
+ * the deque:
+ *
+ * ||<)(> ''Operation'' ||<)(> ''Deque method'' ||
+ * || push an element || {@link offer_head} ||
+ * || peek an element || {@link peek_head} ||
+ * || pop an element || {@link poll_head} ||
+ */
+[GenericAccessors]
+public interface Vala.Deque<G> : Queue<G> {
+ /**
+ * Offers the specified element to the head of this deque.
+ *
+ * @param element the element to offer to the queue
+ *
+ * @return ``true`` if the element was added to the queue
+ */
+ public abstract bool offer_head (G element);
+
+ /**
+ * Peeks (retrieves, but not remove) an element from this queue.
+ *
+ * @return the element peeked from the queue (or ``null`` if none was
+ * available)
+ */
+ public abstract G? peek_head ();
+
+ /**
+ * Polls (retrieves and remove) an element from the head of this queue.
+ *
+ * @return the element polled from the queue (or ``null`` if none was
+ * available)
+ */
+ public abstract G? poll_head ();
+
+ /**
+ * Drains the specified amount of elements from the head of this queue in
+ * the specified recipient collection.
+ *
+ * @param recipient the recipient collection to drain the elements to
+ * @param amount the amount of elements to drain
+ *
+ * @return the amount of elements that were actually drained
+ */
+ public abstract int drain_head (Collection<G> recipient, int amount = -1);
+
+ /**
+ * Offers the specified element to the tail of this deque
+ *
+ * @param element the element to offer to the queue
+ *
+ * @return ``true`` if the element was added to the queue
+ */
+ public abstract bool offer_tail (G element);
+
+ /**
+ * Peeks (retrieves, but not remove) an element from the tail of this
+ * queue.
+ *
+ * @return the element peeked from the queue (or ``null`` if none was
+ * available)
+ */
+ public abstract G? peek_tail ();
+
+ /**
+ * Polls (retrieves and remove) an element from the tail of this queue.
+ *
+ * @return the element polled from the queue (or ``null`` if none was
+ * available)
+ */
+ public abstract G? poll_tail ();
+
+ /**
+ * Drains the specified amount of elements from the tail of this queue in
+ * the specified recipient collection.
+ *
+ * @param recipient the recipient collection to drain the elements to
+ * @param amount the amount of elements to drain
+ *
+ * @return the amount of elements that were actually drained
+ */
+ public abstract int drain_tail (Collection<G> recipient, int amount = -1);
+}
diff --git a/gee/functions.vala b/gee/functions.vala
new file mode 100644
index 0000000..a805bc8
--- /dev/null
+++ b/gee/functions.vala
@@ -0,0 +1,152 @@
+/* functions.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois, Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes' Villevalois <ptitjes free fr>
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+using GLib;
+
+namespace Vala {
+
+ /**
+ * Helpers for equal, hash and compare functions.
+ *
+ * With those functions, you can retrieve the equal, hash and compare
+ * functions that best match your element, key or value types. Supported
+ * types are (non-boxed) primitive, string and ``Object`` types.
+ *
+ * A special care is taken for classes inheriting from the
+ * {@link Comparable} interface. For such types, an appropriate compare
+ * function is returned that calls {@link Comparable.compare_to}.
+ *
+ */
+ namespace Functions {
+
+ /**
+ * Get a equality testing function for a given type.
+ *
+ * @param t the type which to get an equality testing function for.
+ *
+ * @return the equality testing function corresponding to the given type.
+ */
+ public static EqualDataFunc get_equal_func_for (Type t) {
+ if (t == typeof (string)) {
+ return (a, b) => {
+ if (a == b)
+ return true;
+ else if (a == null || b == null)
+ return false;
+ else
+ return str_equal ((string) a, (string) b);
+ };
+ } else if (t.is_a (typeof (Hashable))) {
+ return (a, b) => {
+ if (a == b)
+ return true;
+ else if (a == null || b == null)
+ return false;
+ else
+ return ((Hashable<Hashable>) a).equal_to ((Hashable) b);
+ };
+ } else if (t.is_a (typeof (Comparable))) {
+ return (a, b) => {
+ if (a == b)
+ return true;
+ else if (a == null || b == null)
+ return false;
+ else
+ return ((Comparable<Comparable>) a).compare_to ((Comparable)
b) == 0;};
+ } else {
+ return (a, b) => {return direct_equal (a, b);};
+ }
+ }
+
+ /**
+ * Get a hash function for a given type.
+ *
+ * @param t the type which to get the hash function for.
+ *
+ * @return the hash function corresponding to the given type.
+ */
+ public static HashDataFunc get_hash_func_for (Type t) {
+ if (t == typeof (string)) {
+ return (a) => {
+ if (a == null)
+ return (uint)0xdeadbeef;
+ else
+ return str_hash ((string) a);
+ };
+ } else if (t.is_a (typeof (Hashable))) {
+ return (a) => {
+ if (a == null)
+ return (uint)0xdeadbeef;
+ else
+ return ((Hashable) a).hash();
+ };
+ } else {
+ return (a) => {return direct_hash (a);};
+ }
+ }
+
+ /**
+ * Get a comparator function for a given type.
+ *
+ * @param t the type which to get a comparator function for.
+ *
+ * @return the comparator function corresponding to the given type.
+ */
+ public static CompareDataFunc get_compare_func_for (Type t) {
+ if (t == typeof (string)) {
+ return (a, b) => {
+ if (a == b)
+ return 0;
+ else if (a == null)
+ return -1;
+ else if (b == null)
+ return 1;
+ else
+ return strcmp((string) a, (string) b);
+ };
+ } else if (t.is_a (typeof (Comparable))) {
+ return (a, b) => {
+ if (a == b)
+ return 0;
+ else if (a == null)
+ return -1;
+ else if (b == null)
+ return 1;
+ else
+ return ((Comparable<Comparable>) a).compare_to ((Comparable)
b);
+ };
+ } else {
+ return (_val1, _val2) => {
+ long val1 = (long)_val1, val2 = (long)_val2;
+ if (val1 > val2) {
+ return 1;
+ } else if (val1 == val2) {
+ return 0;
+ } else {
+ return -1;
+ }
+ };
+ }
+ }
+ }
+}
diff --git a/gee/hashable.vala b/gee/hashable.vala
new file mode 100644
index 0000000..9b806f1
--- /dev/null
+++ b/gee/hashable.vala
@@ -0,0 +1,44 @@
+/* hashable.vala
+ *
+ * Copyright (C) 2010 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkwonik2 gmail com>
+ */
+
+/**
+ * This interface defines a hash function amongs instances of each class
+ * implementing it.
+ *
+ * @see Comparable
+ */
+public interface Vala.Hashable<G> : Object {
+ /**
+ * Computes hash for an objects. Two hashes of equal objects have to be
+ * equal. Hash have to not change during lifetime of object.
+ *
+ * @return hash of an object
+ */
+ public abstract uint hash ();
+
+ /**
+ * Compares this object with the specifed object.
+ *
+ * @return true if objects are equal
+ */
+ public abstract bool equal_to (G object);
+}
diff --git a/gee/hashmap.vala b/gee/hashmap.vala
index 9085f10..158e787 100644
--- a/gee/hashmap.vala
+++ b/gee/hashmap.vala
@@ -25,73 +25,162 @@
using GLib;
/**
- * Hashtable implementation of the Map interface.
+ * Hash table implementation of the {@link Map} interface.
+ *
+ * This implementation is better fit for highly heterogenous key values.
+ * In case of high key hashes redundancy or higher amount of data prefer using
+ * tree implementation like {@link TreeMap}.
+ *
+ * @see TreeMap
*/
-public class Vala.HashMap<K,V> : Map<K,V> {
+public class Vala.HashMap<K,V> : Vala.AbstractMap<K,V> {
+ /**
+ * {@inheritDoc}
+ */
public override int size {
get { return _nnodes; }
}
- public HashFunc<K> key_hash_func {
- set { _key_hash_func = value; }
+ /**
+ * {@inheritDoc}
+ */
+ public override bool read_only {
+ get { return false; }
}
- public EqualFunc<K> key_equal_func {
- set { _key_equal_func = value; }
+ /**
+ * {@inheritDoc}
+ */
+ public override Set<K> keys {
+ owned get {
+ Set<K> keys = _keys;
+ if (_keys == null) {
+ keys = new KeySet<K,V> (this);
+ _keys = keys;
+ keys.add_weak_pointer ((void**) (&_keys));
+ }
+ return keys;
+ }
}
- public EqualFunc<V> value_equal_func {
- set { _value_equal_func = value; }
+ /**
+ * {@inheritDoc}
+ */
+ public override Collection<V> values {
+ owned get {
+ Collection<K> values = _values;
+ if (_values == null) {
+ values = new ValueCollection<K,V> (this);
+ _values = values;
+ values.add_weak_pointer ((void**) (&_values));
+ }
+ return values;
+ }
}
+ /**
+ * {@inheritDoc}
+ */
+ public override Set<Map.Entry<K,V>> entries {
+ owned get {
+ Set<Map.Entry<K,V>> entries = _entries;
+ if (_entries == null) {
+ entries = new EntrySet<K,V> (this);
+ _entries = entries;
+ entries.add_weak_pointer ((void**) (&_entries));
+ }
+ return entries;
+ }
+ }
+
+ /**
+ * The keys' hash function.
+ */
+ [CCode (notify = false)]
+ public HashDataFunc<K> key_hash_func { private set; get; }
+
+ /**
+ * The keys' equality testing function.
+ */
+ [CCode (notify = false)]
+ public EqualDataFunc<K> key_equal_func { private set; get; }
+
+ /**
+ * The values' equality testing function.
+ */
+ [CCode (notify = false)]
+ public EqualDataFunc<V> value_equal_func { private set; get; }
+
private int _array_size;
private int _nnodes;
private Node<K,V>[] _nodes;
+ private weak Set<K> _keys;
+ private weak Collection<V> _values;
+ private weak Set<Map.Entry<K,V>> _entries;
+
// concurrent modification protection
private int _stamp = 0;
- private HashFunc<K> _key_hash_func;
- private EqualFunc<K> _key_equal_func;
- private EqualFunc<V> _value_equal_func;
-
private const int MIN_SIZE = 11;
private const int MAX_SIZE = 13845163;
- public HashMap (HashFunc<K> key_hash_func = GLib.direct_hash, EqualFunc<K> key_equal_func =
GLib.direct_equal, EqualFunc<V> value_equal_func = GLib.direct_equal) {
+ /**
+ * Constructs a new, empty hash map.
+ *
+ * If not provided, the functions parameters are requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param key_hash_func an optional key hash function
+ * @param key_equal_func an optional key equality testing function
+ * @param value_equal_func an optional value equality testing function
+ */
+ public HashMap (owned HashDataFunc<K>? key_hash_func = null, owned EqualDataFunc<K>? key_equal_func =
null, owned EqualDataFunc<V>? value_equal_func = null) {
+ if (key_hash_func == null) {
+ key_hash_func = Functions.get_hash_func_for (typeof (K));
+ }
+ if (key_equal_func == null) {
+ key_equal_func = Functions.get_equal_func_for (typeof (K));
+ }
+ if (value_equal_func == null) {
+ value_equal_func = Functions.get_equal_func_for (typeof (V));
+ }
this.key_hash_func = key_hash_func;
this.key_equal_func = key_equal_func;
this.value_equal_func = value_equal_func;
+
_array_size = MIN_SIZE;
_nodes = new Node<K,V>[_array_size];
}
- public override Set<K> get_keys () {
- return new KeySet<K,V> (this);
- }
-
- public override Collection<V> get_values () {
- return new ValueCollection<K,V> (this);
- }
-
- public override Vala.MapIterator<K,V> map_iterator () {
- return new MapIterator<K,V> (this);
- }
-
private Node<K,V>** lookup_node (K key) {
- uint hash_value = _key_hash_func (key);
+ uint hash_value = key_hash_func (key);
Node<K,V>** node = &_nodes[hash_value % _array_size];
- while ((*node) != null && (hash_value != (*node)->key_hash || !_key_equal_func ((*node)->key,
key))) {
+ while ((*node) != null && (hash_value != (*node)->key_hash || !key_equal_func ((*node)->key,
key))) {
node = &((*node)->next);
}
return node;
}
- public override bool contains (K key) {
+ /**
+ * {@inheritDoc}
+ */
+ public override bool has_key (K key) {
Node<K,V>** node = lookup_node (key);
return (*node != null);
}
+ /**
+ * {@inheritDoc}
+ */
+ public override bool has (K key, V value) {
+ Node<K,V>** node = lookup_node (key);
+ return (*node != null && value_equal_func ((*node)->value, value));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
public override V? get (K key) {
Node<K,V>* node = (*lookup_node (key));
if (node != null) {
@@ -101,12 +190,15 @@ public class Vala.HashMap<K,V> : Map<K,V> {
}
}
+ /**
+ * {@inheritDoc}
+ */
public override void set (K key, V value) {
Node<K,V>** node = lookup_node (key);
if (*node != null) {
(*node)->value = value;
} else {
- uint hash_value = _key_hash_func (key);
+ uint hash_value = key_hash_func (key);
*node = new Node<K,V> (key, value, hash_value);
_nnodes++;
resize ();
@@ -114,25 +206,20 @@ public class Vala.HashMap<K,V> : Map<K,V> {
_stamp++;
}
- public override bool remove (K key) {
- Node<K,V>** node = lookup_node (key);
- if (*node != null) {
- Node<K,V> next = (owned) (*node)->next;
-
- (*node)->key = null;
- (*node)->value = null;
- delete *node;
-
- *node = (owned) next;
-
- _nnodes--;
- resize ();
- _stamp++;
- return true;
+ /**
+ * {@inheritDoc}
+ */
+ public override bool unset (K key, out V? value = null) {
+ bool b = unset_helper (key, out value);
+ if(b) {
+ resize();
}
- return false;
+ return b;
}
+ /**
+ * {@inheritDoc}
+ */
public override void clear () {
for (int i = 0; i < _array_size; i++) {
Node<K,V> node = (owned) _nodes[i];
@@ -147,7 +234,36 @@ public class Vala.HashMap<K,V> : Map<K,V> {
resize ();
}
- private void resize () {
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.MapIterator<K,V> map_iterator () {
+ return new MapIterator<K,V> (this);
+ }
+
+ private inline bool unset_helper (K key, out V? value = null) {
+ Node<K,V>** node = lookup_node (key);
+ if (*node != null) {
+ Node<K,V> next = (owned) (*node)->next;
+
+ value = (owned) (*node)->value;
+
+ (*node)->key = null;
+ (*node)->value = null;
+ delete *node;
+
+ *node = (owned) next;
+
+ _nnodes--;
+ _stamp++;
+ return true;
+ } else {
+ value = null;
+ }
+ return false;
+ }
+
+ private inline void resize () {
if ((_array_size >= 3 * _nnodes && _array_size >= MIN_SIZE) ||
(3 * _array_size <= _nnodes && _array_size < MAX_SIZE)) {
int new_array_size = (int) SpacedPrimes.closest (_nnodes);
@@ -180,27 +296,48 @@ public class Vala.HashMap<K,V> : Map<K,V> {
public V value;
public Node<K,V> next;
public uint key_hash;
+ public unowned Map.Entry<K,V>? entry;
public Node (owned K k, owned V v, uint hash) {
key = (owned) k;
value = (owned) v;
key_hash = hash;
+ entry = null;
}
}
- private class KeySet<K,V> : Set<K> {
- public HashMap<K,V> map {
- set { _map = value; }
+ private class Entry<K,V> : Map.Entry<K,V> {
+ private unowned Node<K,V> _node;
+
+ public static Map.Entry<K,V> entry_for<K,V> (Node<K,V> node) {
+ Map.Entry<K,V> result = node.entry;
+ if (node.entry == null) {
+ result = new Entry<K,V> (node);
+ node.entry = result;
+ result.add_weak_pointer ((void**) (&node.entry));
+ }
+ return result;
}
- private HashMap<K,V> _map;
+ public Entry (Node<K,V> node) {
+ _node = node;
+ }
- public KeySet (HashMap map) {
- this.map = map;
+ public override K key { get { return _node.key; } }
+
+ public override V value {
+ get { return _node.value; }
+ set { _node.value = value; }
}
- public override Type get_element_type () {
- return typeof (K);
+ public override bool read_only { get { return false; } }
+ }
+
+ private class KeySet<K,V> : AbstractSet<K> {
+ private HashMap<K,V> _map;
+
+ public KeySet (HashMap map) {
+ _map = map;
}
public override Iterator<K> iterator () {
@@ -211,6 +348,10 @@ public class Vala.HashMap<K,V> : Map<K,V> {
get { return _map.size; }
}
+ public override bool read_only {
+ get { return true; }
+ }
+
public override bool add (K key) {
assert_not_reached ();
}
@@ -224,170 +365,343 @@ public class Vala.HashMap<K,V> : Map<K,V> {
}
public override bool contains (K key) {
- return _map.contains (key);
+ return _map.has_key (key);
+ }
+
+ public bool add_all (Collection<K> collection) {
+ assert_not_reached ();
+ }
+
+ public bool remove_all (Collection<K> collection) {
+ assert_not_reached ();
}
+
+ public bool retain_all (Collection<K> collection) {
+ assert_not_reached ();
+ }
+
}
- private class MapIterator<K,V> : Vala.MapIterator<K, V> {
- public HashMap<K,V> map {
- set {
- _map = value;
- _stamp = _map._stamp;
+ private class ValueCollection<K,V> : AbstractCollection<V> {
+ private HashMap<K,V> _map;
+
+ public ValueCollection (HashMap map) {
+ _map = map;
+ }
+
+ public override Iterator<V> iterator () {
+ return new ValueIterator<K,V> (_map);
+ }
+
+ public override int size {
+ get { return _map.size; }
+ }
+
+ public override bool read_only {
+ get { return true; }
+ }
+
+ public override bool add (V value) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public override bool remove (V value) {
+ assert_not_reached ();
+ }
+
+ public override bool contains (V value) {
+ Iterator<V> it = iterator ();
+ while (it.next ()) {
+ if (_map.value_equal_func (it.get (), value)) {
+ return true;
+ }
}
+ return false;
+ }
+
+ public bool add_all (Collection<V> collection) {
+ assert_not_reached ();
+ }
+
+ public bool remove_all (Collection<V> collection) {
+ assert_not_reached ();
+ }
+
+ public bool retain_all (Collection<V> collection) {
+ assert_not_reached ();
}
+ }
+ private class EntrySet<K,V> : AbstractSet<Map.Entry<K, V>> {
private HashMap<K,V> _map;
- private int _index = -1;
- private weak Node<K,V> _node;
+
+ public EntrySet (HashMap<K,V> map) {
+ _map = map;
+ }
+
+ public override Iterator<Map.Entry<K, V>> iterator () {
+ return new EntryIterator<K,V> (_map);
+ }
+
+ public override int size {
+ get { return _map.size; }
+ }
+
+ public override bool read_only {
+ get { return true; }
+ }
+
+ public override bool add (Map.Entry<K, V> entry) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public override bool remove (Map.Entry<K, V> entry) {
+ assert_not_reached ();
+ }
+
+ public override bool contains (Map.Entry<K, V> entry) {
+ return _map.has (entry.key, entry.value);
+ }
+
+ public bool add_all (Collection<Map.Entry<K, V>> entries) {
+ assert_not_reached ();
+ }
+
+ public bool remove_all (Collection<Map.Entry<K, V>> entries) {
+ assert_not_reached ();
+ }
+
+ public bool retain_all (Collection<Map.Entry<K, V>> entries) {
+ assert_not_reached ();
+ }
+ }
+
+ private abstract class NodeIterator<K,V> : Object {
+ protected HashMap<K,V> _map;
+ protected int _index = -1;
+ protected weak Node<K,V> _node;
+ protected weak Node<K,V> _next;
// concurrent modification protection
- private int _stamp;
+ protected int _stamp;
- public MapIterator (HashMap map) {
- this.map = map;
+ public NodeIterator (HashMap map) {
+ _map = map;
+ _stamp = _map._stamp;
}
- public override bool next () {
- if (_node != null) {
- _node = _node.next;
- }
- while (_node == null && _index + 1 < _map._array_size) {
- _index++;
- _node = _map._nodes[_index];
+ public bool next () {
+ assert (_stamp == _map._stamp);
+ if (!has_next ()) {
+ return false;
}
+ _node = _next;
+ _next = null;
return (_node != null);
}
- public override K? get_key () {
+ public bool has_next () {
assert (_stamp == _map._stamp);
- assert (_node != null);
- return _node.key;
+ if (_next == null) {
+ _next = _node;
+ if (_next != null) {
+ _next = _next.next;
+ }
+ while (_next == null && _index + 1 < _map._array_size) {
+ _index++;
+ _next = _map._nodes[_index];
+ }
+ }
+ return (_next != null);
}
- public override V? get_value () {
- assert (_stamp == _map._stamp);
- assert (_node != null);
- return _node.value;
+ public virtual bool read_only {
+ get {
+ return true;
+ }
}
- }
- private class KeyIterator<K,V> : Iterator<K> {
- public HashMap<K,V> map {
- set {
- _map = value;
- _stamp = _map._stamp;
+ public bool valid {
+ get {
+ return _node != null;
}
}
+ }
- private HashMap<K,V> _map;
- private int _index = -1;
- private weak Node<K,V> _node;
+ private class KeyIterator<K,V> : NodeIterator<K,V>, Traversable<K>, Iterator<K> {
+ public KeyIterator (HashMap map) {
+ base (map);
+ }
- // concurrent modification protection
- private int _stamp;
+ public new K get () {
+ assert (_stamp == _map._stamp);
+ assert (_node != null);
+ return _node.key;
+ }
- public KeyIterator (HashMap map) {
- this.map = map;
+ public void remove () {
+ assert_not_reached ();
}
- public override bool next () {
+ public bool foreach(ForallFunc<K> f) {
if (_node != null) {
- _node = _node.next;
- }
- while (_node == null && _index + 1 < _map._array_size) {
- _index++;
- _node = _map._nodes[_index];
+ if (!f(_node.key)) {
+ return false;
+ }
+ if(_next == null) {
+ _next = _node.next;
+ }
}
- return (_node != null);
+ do {
+ while(_next != null) {
+ _node = _next;
+ if (!f(_node.key)) {
+ return false;
+ }
+ _next = _next.next;
+ }
+ if (_index + 1 < _map._array_size) {
+ _next = _map._nodes[++_index];
+ } else {
+ return true;
+ }
+ } while(true);
+ }
+ }
+
+ private class MapIterator<K,V> : NodeIterator<K,V>, Vala.MapIterator<K,V> {
+ public MapIterator (HashMap map) {
+ base (map);
}
- public override K? get () {
+ public new K get_key () {
assert (_stamp == _map._stamp);
assert (_node != null);
return _node.key;
}
- }
- private class ValueCollection<K,V> : Collection<V> {
- public HashMap<K,V> map {
- set { _map = value; }
+ public void unset () {
+ assert (_stamp == _map._stamp);
+ assert (_node != null);
+ has_next ();
+ _map.unset_helper (_node.key);
+ _node = null;
+ _stamp = _map._stamp;
}
- private HashMap<K,V> _map;
-
- public ValueCollection (HashMap map) {
- this.map = map;
+ public V get_value () {
+ assert (_stamp == _map._stamp);
+ assert (_node != null);
+ return _node.value;
}
- public override Type get_element_type () {
- return typeof (V);
+ public void set_value (V value) {
+ assert (_stamp == _map._stamp);
+ assert (_node != null);
+ _map.set (_node.key, value);
+ _stamp = _map._stamp;
}
- public override Iterator<V> iterator () {
- return new ValueIterator<K,V> (_map);
+ public bool mutable {
+ get {
+ return true;
+ }
}
- public override int size {
- get { return _map.size; }
+ public override bool read_only {
+ get {
+ return false;
+ }
}
+ }
- public override bool add (V value) {
- assert_not_reached ();
+ private class ValueIterator<K,V> : NodeIterator<K,V>, Traversable<V>, Iterator<V> {
+ public ValueIterator (HashMap map) {
+ base (map);
}
- public override void clear () {
- assert_not_reached ();
+ public new V get () {
+ assert (_stamp == _map._stamp);
+ assert (_node != null);
+ return _node.value;
}
- public override bool remove (V value) {
+ public void remove () {
assert_not_reached ();
}
- public override bool contains (V value) {
- Iterator<V> it = iterator ();
- while (it.next ()) {
- if (_map._value_equal_func (it.get (), value)) {
- return true;
+ public bool foreach(ForallFunc<V> f) {
+ if (_node != null) {
+ if (!f(_node.value)) {
+ return false;
+ }
+ if(_next == null) {
+ _next = _node.next;
}
}
- return false;
+ do {
+ while(_next != null) {
+ _node = _next;
+ if (!f(_node.value)) {
+ return false;
+ }
+ _next = _next.next;
+ }
+ if (_index + 1 < _map._array_size) {
+ _next = _map._nodes[++_index];
+ } else {
+ return true;
+ }
+ } while(true);
}
}
- private class ValueIterator<K,V> : Iterator<V> {
- public HashMap<K,V> map {
- set {
- _map = value;
- _stamp = _map._stamp;
- }
+ private class EntryIterator<K,V> : NodeIterator<K,V>, Traversable<Map.Entry<K,V>>,
Iterator<Map.Entry<K,V>> {
+ public EntryIterator (HashMap map) {
+ base (map);
}
- private HashMap<V,K> _map;
- private int _index = -1;
- private weak Node<K,V> _node;
-
- // concurrent modification protection
- private int _stamp;
+ public new Map.Entry<K,V> get () {
+ assert (_stamp == _map._stamp);
+ assert (_node != null);
+ return Entry<K,V>.entry_for<K,V> (_node);
+ }
- public ValueIterator (HashMap map) {
- this.map = map;
+ public void remove () {
+ assert_not_reached ();
}
- public override bool next () {
+ public bool foreach(ForallFunc<Map.Entry<K,V>> f) {
if (_node != null) {
- _node = _node.next;
- }
- while (_node == null && _index + 1 < _map._array_size) {
- _index++;
- _node = _map._nodes[_index];
+ if (!f(Entry<K,V>.entry_for<K,V> (_node))) {
+ return false;
+ }
+ if(_next == null) {
+ _next = _node.next;
+ }
}
- return (_node != null);
- }
-
- public override V? get () {
- assert (_stamp == _map._stamp);
- assert (_node != null);
- return _node.value;
+ do {
+ while(_next != null) {
+ _node = _next;
+ if (!f(Entry<K,V>.entry_for<K,V> (_node))) {
+ return false;
+ }
+ _next = _next.next;
+ }
+ if (_index + 1 < _map._array_size) {
+ _next = _map._nodes[++_index];
+ } else {
+ return true;
+ }
+ } while(true);
}
}
}
diff --git a/gee/hashmultimap.vala b/gee/hashmultimap.vala
new file mode 100644
index 0000000..ca57fb8
--- /dev/null
+++ b/gee/hashmultimap.vala
@@ -0,0 +1,76 @@
+/* hashmultimap.vala
+ *
+ * Copyright (C) 2009 Ali Sabil
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Ali Sabil <ali sabil gmail com>
+ */
+
+/**
+ * Hash table implementation of the {@link MultiMap} interface.
+ */
+public class Vala.HashMultiMap<K,V> : AbstractMultiMap<K,V> {
+ public HashDataFunc<K> key_hash_func {
+ get { return ((HashMap<K, Set<V>>) _storage_map).key_hash_func; }
+ }
+
+ public EqualDataFunc<K> key_equal_func {
+ get { return ((HashMap<K, Set<V>>) _storage_map).key_equal_func; }
+ }
+
+ [CCode (notify = false)]
+ public HashDataFunc<V> value_hash_func { private set; get; }
+
+ [CCode (notify = false)]
+ public EqualDataFunc<V> value_equal_func { private set; get; }
+
+ /**
+ * Constructs a new, empty hash multimap.
+ *
+ * If not provided, the functions parameters are requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param key_hash_func an optional key hash function
+ * @param key_equal_func an optional key equality testing function
+ * @param value_hash_func an optional value hash function
+ * @param value_equal_func an optional value equality testing function
+ */
+ public HashMultiMap (owned HashDataFunc<K>? key_hash_func = null, owned EqualDataFunc<K>?
key_equal_func = null,
+ owned HashDataFunc<V>? value_hash_func = null, owned EqualDataFunc<V>?
value_equal_func = null) {
+ base (new HashMap<K, Set<V>> (key_hash_func, key_equal_func, Functions.get_equal_func_for
(typeof (Set))));
+ if (value_hash_func == null) {
+ value_hash_func = Functions.get_hash_func_for (typeof (V));
+ }
+ if (value_equal_func == null) {
+ value_equal_func = Functions.get_equal_func_for (typeof (V));
+ }
+ this.value_hash_func = value_hash_func;
+ this.value_equal_func = value_equal_func;
+ }
+
+ protected override Collection<V> create_value_storage () {
+ return new HashSet<V> (_value_hash_func, _value_equal_func);
+ }
+
+ protected override MultiSet<K> create_multi_key_set () {
+ return new HashMultiSet<K> (key_hash_func, key_equal_func);
+ }
+
+ protected override EqualDataFunc get_value_equal_func () {
+ return _value_equal_func;
+ }
+}
diff --git a/gee/hashmultiset.vala b/gee/hashmultiset.vala
new file mode 100644
index 0000000..78b8500
--- /dev/null
+++ b/gee/hashmultiset.vala
@@ -0,0 +1,47 @@
+/* hashmultiset.vala
+ *
+ * Copyright (C) 2009 Ali Sabil
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Ali Sabil <ali sabil gmail com>
+ */
+
+/**
+ * Hash table implementation of the {@link MultiSet} interface.
+ */
+public class Vala.HashMultiSet<G> : AbstractMultiSet<G> {
+ public HashDataFunc<G> hash_func {
+ get { return ((HashMap<G, int>) _storage_map).key_hash_func; }
+ }
+
+ public EqualDataFunc<G> equal_func {
+ get { return ((HashMap<G, int>) _storage_map).key_equal_func; }
+ }
+
+ /**
+ * Constructs a new, empty hash multi set.
+ *
+ * If not provided, the functions parameters are requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param hash_func an optional element hash function
+ * @param equal_func an optional element equality testing function
+ */
+ public HashMultiSet (HashDataFunc<G>? hash_func = null, EqualDataFunc<G>? equal_func = null) {
+ base (new HashMap<G, int> (hash_func, equal_func));
+ }
+}
diff --git a/gee/hashset.vala b/gee/hashset.vala
index 6ca0dfa..e4821d7 100644
--- a/gee/hashset.vala
+++ b/gee/hashset.vala
@@ -24,21 +24,46 @@
using GLib;
+namespace Vala {
+ public delegate uint HashDataFunc<T> (T v);
+ public delegate bool EqualDataFunc<T> (T a, T b);
+}
+
/**
- * Hashtable implementation of the Set interface.
+ * Hash table implementation of the {@link Set} interface.
+ *
+ * This implementation is better fit for highly heterogenous values.
+ * In case of high value hashes redundancy or higher amount of data prefer using
+ * tree implementation like {@link TreeSet}.
+ *
+ * @see TreeSet
*/
-public class Vala.HashSet<G> : Set<G> {
+public class Vala.HashSet<G> : AbstractSet<G> {
+ /**
+ * {@inheritDoc}
+ */
public override int size {
get { return _nnodes; }
}
- public HashFunc<G> hash_func {
- set { _hash_func = value; }
+ /**
+ * {@inheritDoc}
+ */
+ public override bool read_only {
+ get { return false; }
}
- public EqualFunc<G> equal_func {
- set { _equal_func = value; }
- }
+ /**
+ * The elements' hash function.
+ */
+ [CCode (notify = false)]
+ public HashDataFunc<G> hash_func { private set; get; }
+
+ /**
+ * The elements' equality testing function.
+ */
+ [CCode (notify = false)]
+ public EqualDataFunc<G> equal_func { private set; get; }
private int _array_size;
private int _nnodes;
@@ -47,13 +72,25 @@ public class Vala.HashSet<G> : Set<G> {
// concurrent modification protection
private int _stamp = 0;
- private HashFunc<G> _hash_func;
- private EqualFunc<G> _equal_func;
-
private const int MIN_SIZE = 11;
private const int MAX_SIZE = 13845163;
- public HashSet (HashFunc<G> hash_func = GLib.direct_hash, EqualFunc<G> equal_func =
GLib.direct_equal) {
+ /**
+ * Constructs a new, empty hash set.
+ *
+ * If not provided, the functions parameters are requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param hash_func an optional hash function
+ * @param equal_func an optional equality testing function
+ */
+ public HashSet (owned HashDataFunc<G>? hash_func = null, owned EqualDataFunc<G>? equal_func = null) {
+ if (hash_func == null) {
+ hash_func = Functions.get_hash_func_for (typeof (G));
+ }
+ if (equal_func == null) {
+ equal_func = Functions.get_equal_func_for (typeof (G));
+ }
this.hash_func = hash_func;
this.equal_func = equal_func;
_array_size = MIN_SIZE;
@@ -61,33 +98,38 @@ public class Vala.HashSet<G> : Set<G> {
}
private Node<G>** lookup_node (G key) {
- uint hash_value = _hash_func (key);
+ uint hash_value = hash_func (key);
Node<G>** node = &_nodes[hash_value % _array_size];
- while ((*node) != null && (hash_value != (*node)->key_hash || !_equal_func ((*node)->key,
key))) {
+ while ((*node) != null && (hash_value != (*node)->key_hash || !equal_func ((*node)->key,
key))) {
node = &((*node)->next);
}
return node;
}
+ /**
+ * {@inheritDoc}
+ */
public override bool contains (G key) {
Node<G>** node = lookup_node (key);
return (*node != null);
}
- public override Type get_element_type () {
- return typeof (G);
- }
-
+ /**
+ * {@inheritDoc}
+ */
public override Vala.Iterator<G> iterator () {
return new Iterator<G> (this);
}
+ /**
+ * {@inheritDoc}
+ */
public override bool add (G key) {
Node<G>** node = lookup_node (key);
if (*node != null) {
return false;
} else {
- uint hash_value = _hash_func (key);
+ uint hash_value = hash_func (key);
*node = new Node<G> (key, hash_value);
_nnodes++;
resize ();
@@ -96,24 +138,20 @@ public class Vala.HashSet<G> : Set<G> {
}
}
+ /**
+ * {@inheritDoc}
+ */
public override bool remove (G key) {
- Node<G>** node = lookup_node (key);
- if (*node != null) {
- Node<G> next = (owned) (*node)->next;
-
- (*node)->key = null;
- delete *node;
-
- *node = (owned) next;
-
- _nnodes--;
+ bool b = remove_helper(key);
+ if(b) {
resize ();
- _stamp++;
- return true;
}
- return false;
+ return b;
}
+ /**
+ * {@inheritDoc}
+ */
public override void clear () {
for (int i = 0; i < _array_size; i++) {
Node<G> node = (owned) _nodes[i];
@@ -127,6 +165,24 @@ public class Vala.HashSet<G> : Set<G> {
resize ();
}
+ private inline bool remove_helper (G key) {
+ Node<G>** node = lookup_node (key);
+ if (*node != null) {
+ assert (*node != null);
+ Node<G> next = (owned) (*node)->next;
+
+ (*node)->key = null;
+ delete *node;
+
+ *node = (owned) next;
+
+ _nnodes--;
+ _stamp++;
+ return true;
+ }
+ return false;
+ }
+
private void resize () {
if ((_array_size >= 3 * _nnodes && _array_size >= MIN_SIZE) ||
(3 * _array_size <= _nnodes && _array_size < MAX_SIZE)) {
@@ -166,41 +222,110 @@ public class Vala.HashSet<G> : Set<G> {
}
}
- private class Iterator<G> : Vala.Iterator<G> {
- public HashSet<G> set {
- set {
- _set = value;
- _stamp = _set._stamp;
- }
- }
-
+ private class Iterator<G> : Object, Traversable<G>, Vala.Iterator<G> {
private HashSet<G> _set;
private int _index = -1;
private weak Node<G> _node;
+ private weak Node<G> _next;
// concurrent modification protection
private int _stamp = 0;
public Iterator (HashSet set) {
- this.set = set;
+ _set = set;
+ _stamp = _set._stamp;
}
- public override bool next () {
- if (_node != null) {
- _node = _node.next;
- }
- while (_node == null && _index + 1 < _set._array_size) {
- _index++;
- _node = _set._nodes[_index];
+ public bool next () {
+ assert (_stamp == _set._stamp);
+ if (!has_next ()) {
+ return false;
}
+ _node = _next;
+ _next = null;
return (_node != null);
}
- public override G? get () {
+ public bool has_next () {
+ assert (_stamp == _set._stamp);
+ if (_next == null) {
+ _next = _node;
+ if (_next != null) {
+ _next = _next.next;
+ }
+ while (_next == null && _index + 1 < _set._array_size) {
+ _index++;
+ _next = _set._nodes[_index];
+ }
+ }
+ return (_next != null);
+ }
+
+ public new G get () {
assert (_stamp == _set._stamp);
assert (_node != null);
return _node.key;
}
+
+ public void remove () {
+ assert (_stamp == _set._stamp);
+ assert (_node != null);
+ has_next ();
+ _set.remove_helper (_node.key);
+ _node = null;
+ _stamp = _set._stamp;
+ }
+
+ public bool read_only {
+ get {
+ return false;
+ }
+ }
+
+ public bool valid {
+ get {
+ return _node != null;
+ }
+ }
+
+ public bool foreach (ForallFunc<G> f) {
+ assert (_stamp == _set._stamp);
+ unowned Node<G>? node = _node, next = _next, current = null, prev = null;
+ if (node != null) {
+ if (!f (node.key)) {
+ return false;
+ }
+ prev = node;
+ current = node.next;
+ }
+ if (next != null) {
+ if (!f (next.key)) {
+ _node = next;
+ _next = null;
+ return false;
+ }
+ prev = next;
+ current = next.next;
+ }
+ do {
+ while (current != null) {
+ if (!f (current.key)) {
+ _node = current;
+ _next = null;
+ return false;
+ }
+ prev = current;
+ current = current.next;
+ }
+ while (current == null && _index + 1 < _set._array_size) {
+ _index++;
+ current = _set._nodes[_index];
+ }
+ } while (current != null);
+ _node = prev;
+ _next = null;
+ return true;
+ }
}
}
diff --git a/gee/hazardpointer.vala b/gee/hazardpointer.vala
new file mode 100644
index 0000000..a26fbeb
--- /dev/null
+++ b/gee/hazardpointer.vala
@@ -0,0 +1,775 @@
+/* hazardpointer.vala
+ *
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Hazard pointer is a method of protecting a pointer shared by many threads.
+ * If you want to use atomic pointer that may be freed you should use following code:
+ *
+ * {{{
+ * string *shared_pointer = ...;
+ * HazardPointer<string> hptr = HazardPointer.get_hazard_pointer (&shared_pointer);
+ * // my_string contains value from shared_pinter. It is valid as long as hptr is alive.
+ * unowned string my_string = ptr.get ();
+ * // instead of delete
+ * ptr.release ((ptr) => {string *sptr = ptr;string ref = (owned)sptr;});
+ * });
+ * }}}
+ *
+ * In some cases you may use helper methods which might involve copying of object (and are unsafe for
unowned objects):
+ * {{{
+ * Gtk.Window *window = ...;
+ * Gtk.Window? local_window = HazardPointer.get_pointer (&window);
+ * HazardPointer.set_pointer (&window, ...)
+ * local_window = HazardPointer.exchange_pointer (&window, null);
+ * HazardPointer.compare_and_exchange (&window, null, local_window);
+ * }}}
+ *
+ * The class also provides helper methods if least significant bits are used for storing flags.
+ *
+ * HazardPointers are not thread-safe (unless documentation states otherwise).
+ */
+[Compact]
+public class Vala.HazardPointer<G> { // FIXME: Make it a struct
+ /**
+ * Creates a hazard pointer for a pointer.
+ *
+ * @param ptr Protected pointer
+ */
+ public HazardPointer (G *ptr) {
+ this._node = acquire ();
+ this._node.set ((void *)ptr);
+ }
+
+ /**
+ * Create a hazard pointer from Node.
+ */
+ internal HazardPointer.from_node (Node node) {
+ this._node = node;
+ }
+
+ /**
+ * Gets hazard pointer from atomic pointer safely.
+ *
+ * @param aptr Atomic pointer.
+ * @param mask Mask of bits.
+ * @param mask_out Result of mask.
+ * @return Hazard pointer containing the element.
+ */
+ public static HazardPointer<G>? get_hazard_pointer<G> (G **aptr, size_t mask = 0, out size_t mask_out
= null) {
+ unowned Node node = acquire ();
+ void *rptr = null;
+ void *ptr = null;
+ mask_out = 0;
+ do {
+ rptr = AtomicPointer.get ((void **)aptr);
+ ptr = (void *)((size_t) rptr & ~mask);
+ mask_out = (size_t) rptr & mask;
+ node.set (ptr);
+ } while (rptr != AtomicPointer.get ((void **)aptr));
+ if (ptr != null) {
+ return new HazardPointer<G>.from_node (node);
+ } else {
+ node.release ();
+ return null;
+ }
+ }
+
+ /**
+ * Copy an object from atomic pointer.
+ *
+ * @param aptr Atomic pointer.
+ * @param mask Mask of flags.
+ * @param mask_out Result of mask.
+ * @return A copy of object from atomic pointer.
+ */
+ public static G? get_pointer<G> (G **aptr, size_t mask = 0, out size_t mask_out = null) {
+ unowned Node node = acquire ();
+ void *rptr = null;
+ void *ptr = null;
+ mask_out = 0;
+ do {
+ rptr = AtomicPointer.get ((void **)aptr);
+ ptr = (void *)((size_t) rptr & ~mask);
+ mask_out = (size_t) rptr & mask;
+ node.set (ptr);
+ } while (rptr != AtomicPointer.get ((void **)aptr));
+ G? res = (G *)ptr;
+ node.release ();
+ return res;
+ }
+
+ /**
+ * Exchange objects safly.
+ *
+ * @param aptr Atomic pointer.
+ * @param new_ptr New value
+ * @param mask Mask of flags.
+ * @param new_mask New mask.
+ * @param old_mask Previous mask mask.
+ * @return Hazard pointer containing old value.
+ */
+ public static HazardPointer<G>? exchange_hazard_pointer<G> (G **aptr, owned G? new_ptr, size_t mask =
0, size_t new_mask = 0, out size_t old_mask = null) {
+ unowned Node? new_node = null;
+ if (new_ptr != null) {
+ new_node = acquire ();
+ new_node.set (new_ptr);
+ }
+ old_mask = 0;
+ void *new_rptr = (void *)((size_t)((owned) new_ptr) | (mask & new_mask));
+ unowned Node node = acquire ();
+ void *rptr = null;
+ void *ptr = null;
+ do {
+ rptr = AtomicPointer.get ((void **)aptr);
+ ptr = (void *)((size_t) rptr & ~mask);
+ old_mask = (size_t) rptr & mask;
+ node.set (ptr);
+ } while (!AtomicPointer.compare_and_exchange((void **)aptr, rptr, new_rptr));
+ if (new_node != null)
+ new_node.release ();
+ if (ptr != null) {
+ return new HazardPointer<G>.from_node (node);
+ } else {
+ node.release ();
+ return null;
+ }
+ }
+
+ /**
+ * Sets object safely
+ *
+ * @param aptr Atomic pointer.
+ * @param new_ptr New value
+ * @param mask Mask of flags.
+ * @param new_mask New mask.
+ */
+ public static void set_pointer<G> (G **aptr, owned G? new_ptr, size_t mask = 0, size_t new_mask = 0) {
+ HazardPointer<G>? ptr = exchange_hazard_pointer<G> (aptr, new_ptr, mask, new_mask, null);
+ if (ptr != null) {
+ DestroyNotify<G> notify = get_destroy_notify<G> ();
+ ptr.release ((owned)notify);
+ }
+ }
+
+ /**
+ * Exchange objects safly.
+ *
+ * @param aptr Atomic pointer.
+ * @param new_ptr New value
+ * @param mask Mask of flags.
+ * @param new_mask New mask.
+ * @param old_mask Previous mask mask.
+ * @return Value that was previously stored.
+ */
+ public static G? exchange_pointer<G> (G **aptr, owned G? new_ptr, size_t mask = 0, size_t new_mask =
0, out size_t old_mask = null) {
+ HazardPointer<G>? ptr = exchange_hazard_pointer<G> (aptr, new_ptr, mask, new_mask, out
old_mask);
+ G? rptr = ptr != null ? ptr.get () : null;
+ return rptr;
+ }
+
+ /**
+ * Compares and exchanges objects.
+ *
+ * @param aptr Atomic pointer.
+ * @param old_ptr Old pointer.
+ * @param _new_ptr New value.
+ * @param old_mask Old mask.
+ * @param new_mask New mask.
+ * @return Value that was previously stored.
+ */
+ public static bool compare_and_exchange_pointer<G> (G **aptr, G? old_ptr, owned G? _new_ptr, size_t
mask = 0, size_t old_mask = 0, size_t new_mask = 0) {
+ G *new_ptr = (owned)_new_ptr;
+ void *new_rptr = (void *)((size_t)(new_ptr) | (mask & new_mask));
+ void *old_rptr = (void *)((size_t)(old_ptr) | (mask & old_mask));
+ bool success = AtomicPointer.compare_and_exchange((void **)aptr, old_rptr, new_rptr);
+ if (success) {
+ DestroyNotify<G> notify = get_destroy_notify<G> ();
+ if (old_ptr != null) {
+ Context.get_current_context ()->release_ptr (old_ptr, (owned)notify);
+ }
+ } else if (new_ptr != null) {
+ _new_ptr = (owned)new_ptr;
+ }
+ return success;
+ }
+
+ ~HazardPointer () {
+ _node.release ();
+ }
+
+ /**
+ * Gets the pointer hold by hazard pointer.
+ *
+ * @param other_thread Have to be set to ``true`` if accessed from thread that did not create this
thread.
+ * @return The value hold by pointer.
+ */
+ public inline new unowned G get (bool other_thread = false) {
+ return _node[other_thread];
+ }
+
+ /**
+ * Free the pointer.
+ *
+ * @param notify method freeing object
+ */
+ public void release (owned DestroyNotify notify) {
+ unowned G item = _node[false];
+ _node.set (null);
+ if (item != null) {
+ Context.get_current_context ()->release_ptr (item, (owned)notify);
+ }
+ }
+
+ /**
+ * Sets default policy (i.e. default policy for user-created contexts).
+ * The policy must be concrete and should not be blocking.
+ *
+ * @param policy New default policy.
+ */
+ public static void set_default_policy (Policy policy) requires (policy.is_concrete ()) {
+ if (policy.is_blocking ())
+ warning ("Setting blocking defautl Vala.HazardPointer.Policy (there may be a
deadlock).\n");
+ AtomicInt.set(ref _default_policy, (int)policy);
+ }
+
+ /**
+ * Sets thread exit policy (i.e. default policy for the top-most Context).
+ * The policy must be concrete and should not be unsafe.
+ *
+ * @param policy New thread policy.
+ */
+ public static void set_thread_exit_policy (Policy policy) requires (policy.is_concrete ()) {
+ if (!policy.is_safe ())
+ warning ("Setting unsafe globale thread-exit Vala.HazardPointer.Policy (there may be
a memory leak).\n");
+ AtomicInt.set(ref _thread_exit_policy, (int)policy);
+ }
+
+ /**
+ * Sets release (i.e. how exactly the released objects arefreed).
+ *
+ * The method can be only set before any objects is released and is not thread-safe.
+ *
+ * @param policy New release policy.
+ */
+ public static bool set_release_policy (ReleasePolicy policy) {
+ int old_policy = AtomicInt.get (ref release_policy);
+ if ((old_policy & (sizeof(int) * 8 - 1)) != 0) {
+ critical ("Attempt to change the policy of running helper. Failing.");
+ return false;
+ }
+ if (!AtomicInt.compare_and_exchange (ref release_policy, old_policy, (int)policy)) {
+ critical ("Concurrent access to release policy detected. Failing.");
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Policy determines what happens on exit from Context.
+ */
+ public enum Policy {
+ /**
+ * Performs default action on exit from thread.
+ */
+ DEFAULT,
+ /**
+ * Performs the same action as on exit from current thread.
+ */
+ THREAD_EXIT,
+ /**
+ * Goes through the free list and attempts to free un-freed elements.
+ */
+ TRY_FREE,
+ /**
+ * Goes through the free list and attempts to free un-freed elements
+ * untill all elements are freed.
+ */
+ FREE,
+ /**
+ * Release the un-freed elements to either helper thread or to main loop.
+ * Please note if the operation would block it is not performed.
+ */
+ TRY_RELEASE,
+ /**
+ * Release the un-freed elements to either helper thread or to main loop.
+ * Please note it may block while adding to queue.
+ */
+ RELEASE;
+
+ /**
+ * Checks if the policy is concrete or if it depends on global variables.
+ *
+ * @return ``true`` if this policy does not depend on global variables
+ */
+ public bool is_concrete () {
+ switch (this) {
+ case DEFAULT:
+ case THREAD_EXIT:
+ return false;
+ case TRY_FREE:
+ case FREE:
+ case TRY_RELEASE:
+ case RELEASE:
+ return true;
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ /**
+ * Checks if policy blocks or is lock-free.
+ * Please note that it works on a concrete policy only.
+ *
+ * @return ``true`` if the policy may block the thread.
+ */
+ public bool is_blocking () requires (this.is_concrete ()) {
+ switch (this) {
+ case TRY_FREE:
+ case TRY_RELEASE:
+ return false;
+ case FREE:
+ case RELEASE:
+ return true;
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ /**
+ * Checks if policy guarantees freeing all elements.
+ * Please note that it works on a concrete policy only.
+ *
+ * @return ``true`` if the policy guarantees freeing all elements.
+ */
+ public bool is_safe () requires (this.is_concrete ()) {
+ switch (this) {
+ case TRY_FREE:
+ case TRY_RELEASE:
+ return false;
+ case FREE:
+ case RELEASE:
+ return true;
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ /**
+ * Finds concrete policy which corresponds to given policy.
+ *
+ * @return Policy that corresponds to given policy at given time in given thread.
+ */
+ public Policy to_concrete () ensures (result.is_concrete ()) {
+ switch (this) {
+ case TRY_FREE:
+ case FREE:
+ case TRY_RELEASE:
+ case RELEASE:
+ return this;
+ case DEFAULT:
+ return (Policy) AtomicInt.get (ref _default_policy);
+ case THREAD_EXIT:
+ return (Policy) AtomicInt.get (ref _thread_exit_policy);
+ default:
+ assert_not_reached ();
+
+ }
+ }
+
+ /**
+ * Runs the policy.
+ * @param to_free List containing elements to free.
+ * @return Non-empty list of not freed elements or ``null`` if all elements have been
disposed.
+ */
+ internal ArrayList<FreeNode *>? perform (owned ArrayList<FreeNode *> to_free) {
+ switch (this.to_concrete ()) {
+ case TRY_FREE:
+ return try_free (to_free) ? (owned) to_free : null;
+ case FREE:
+ while (try_free (to_free)) {
+ Thread.yield ();
+ }
+ return null;
+ case TRY_RELEASE:
+ ReleasePolicy.ensure_start ();
+ if (_queue_mutex.trylock ()) {
+ _queue.offer ((owned) to_free);
+ _queue_mutex.unlock ();
+ return null;
+ } else {
+ return (owned) to_free;
+ }
+ case RELEASE:
+ ReleasePolicy.ensure_start ();
+ _queue_mutex.lock ();
+ _queue.offer ((owned) to_free);
+ _queue_mutex.unlock ();
+ return null;
+ default:
+ assert_not_reached ();
+ }
+ }
+ }
+
+ public delegate void DestroyNotify (void *ptr);
+
+ /**
+ * Release policy determines what happens with object freed by Policy.TRY_RELEASE
+ * and Policy.RELEASE.
+ */
+ public enum ReleasePolicy {
+ /**
+ * Libgee spawns helper thread to free those elements.
+ * This is default.
+ */
+ HELPER_THREAD,
+ /**
+ * Libgee uses GLib main loop.
+ * This is recommended for application using GLib main loop.
+ */
+ MAIN_LOOP;
+
+ private static void start (ReleasePolicy self) { // FIXME: Make it non-static [bug 659778]
+ switch (self) {
+ case HELPER_THREAD:
+ try {
+ new Thread<bool> ("<<libgee hazard pointer>>", () => {
+ while (true) {
+ Thread.yield ();
+ attempt_free ();
+ }
+ });
+ } catch (ThreadError error) {
+ assert_not_reached ();
+ }
+ break;
+ case MAIN_LOOP:
+ Idle.add (() => {
+ attempt_free ();
+ return true;
+ }, Priority.LOW);
+ break;
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ /**
+ * Ensures that helper methods are started.
+ */
+ internal static inline void ensure_start () {
+ int policy = AtomicInt.get (ref release_policy);
+ if ((policy & (1 << (sizeof(int) * 8 - 1))) != 0)
+ return;
+ if (_queue_mutex.trylock ()) {
+ policy = AtomicInt.get (ref release_policy);
+ if ((policy & (1 << (sizeof(int) * 8 - 1))) == 0) {
+ _queue = new LinkedList<ArrayList<FreeNode *>> ();
+ // Hack to not lie about successfull setting policy
+ policy = AtomicInt.exchange_and_add (ref release_policy, (int)(1 <<
(sizeof(int) * 8 - 1)));
+ start ((ReleasePolicy) policy);
+ }
+ _queue_mutex.unlock ();
+ }
+ }
+
+ private static inline void attempt_free () {
+ if (_queue_mutex.trylock ()) {
+ Collection<ArrayList<FreeNode *>> temp = new ArrayList<ArrayList<FreeNode *>>
();
+ _queue.drain (temp);
+ _queue_mutex.unlock ();
+ temp.foreach ((x) => {_global_to_free.add_all (x); return true;});
+ }
+ try_free (_global_to_free);
+ }
+ }
+
+ /**
+ * Create a new context. User does not need to create explicitly however it might be benefitial
+ * if he is about to issue bunch of commands he might consider it benefitial to fine-tune the
creation of contexts.
+ *
+ * {{{
+ * Context ctx = new Context ();
+ * lock_free_collection.operation1 ();
+ * // Normally on exit the thread exit operation would be executed but here the default operation of
+ * // child context is executed.
+ * lock_free_collection.operation2 ();
+ * }}}
+ *
+ * Please note that the Context in implicitly part of stack and:
+ *
+ * 1. It cannot be moved between threads.
+ * 2. If in given thread the child (created later) context is alive parent must be alive as well.
+ */
+ [Compact]
+ public class Context { // FIXME: Should be struct
+ public Context (Policy? policy = null) {
+ this._to_free = new ArrayList<FreeNode *> ();
+ this._parent = _current_context.get ();
+ _current_context.set (this, null);
+ if (policy == null) {
+ if (_parent == null) {
+ _policy = (Policy)AtomicInt.get (ref _thread_exit_policy);
+ } else {
+ _policy = (Policy)AtomicInt.get (ref _default_policy);
+ }
+ } else {
+ this._policy = policy.to_concrete ();
+ }
+#if DEBUG
+ stderr.printf ("Entering context %p (policy %s, parent %p)\n", this, _policy != null
? _policy.to_string () : null, _parent);
+#endif
+ }
+
+ ~Context () {
+#if DEBUG
+ stderr.printf ("Exiting context %p (policy %s, parent %p)\n", this, _policy != null ?
_policy.to_string () : null, _parent);
+#endif
+ int size = _to_free.size;
+ bool clean_parent = false;
+ if (size > 0) {
+ ArrayList<FreeNode *>? remaining;
+ if (_parent == null || size >= THRESHOLD)
+ remaining = _policy.perform ((owned) _to_free);
+ else
+ remaining = (owned) _to_free;
+ if (remaining != null) {
+ assert (_parent != null);
+ _parent->_to_free.add_all (remaining);
+ clean_parent = true;
+ }
+ }
+#if DEBUG
+ stderr.printf ("Setting current context to %p\n", _parent);
+#endif
+ _current_context.set (_parent, null);
+ if (clean_parent)
+ HazardPointer.try_free (_parent->_to_free);
+ }
+
+ /**
+ * Tries to free all freed pointer in current context.
+ */
+ public void try_free () {
+ HazardPointer.try_free (_to_free);
+ }
+
+ /**
+ * Ensure that whole context is freed. Plase note that it might block.
+ */
+ public void free_all () {
+ while (HazardPointer.try_free (_to_free))
+ Thread.yield ();
+ }
+
+ /**
+ * Tries to push the current context to releaser.
+ */
+ public void try_release () {
+ if (_queue_mutex.trylock ()) {
+ _queue.offer ((owned) _to_free);
+ _to_free = new ArrayList<FreeNode *> ();
+ _queue_mutex.unlock ();
+ }
+ }
+
+ /**
+ * Pushes the current context to releaser. Plase note that it might block.
+ */
+ public void release () {
+ _queue_mutex.lock ();
+ _queue.offer ((owned) _to_free);
+ _to_free = new ArrayList<FreeNode *> ();
+ _queue_mutex.unlock ();
+ }
+
+ /**
+ * Add pointer to freed array.
+ */
+ internal inline void release_ptr (void *ptr, owned DestroyNotify notify) {
+ FreeNode *node = new FreeNode ();
+ node->pointer = ptr;
+ node->destroy_notify = (owned)notify;
+ _to_free.add (node);
+ if (_to_free.size >= THRESHOLD)
+ HazardPointer.try_free (_to_free);
+ }
+
+ /**
+ * Gets current context.
+ */
+ internal inline static Context *get_current_context () {
+ return _current_context.get ();
+ }
+
+ private inline bool _should_free () {
+ return (_parent == null && _to_free.size > 0) || _to_free.size >= THRESHOLD;
+ }
+
+ internal Context *_parent;
+ internal ArrayList<FreeNode *> _to_free;
+ internal Policy? _policy;
+ internal static StaticPrivate _current_context;
+ internal static StaticPrivate _root_context;
+ private static uint THRESHOLD = 10;
+ }
+
+ /**
+ * Gets a new hazard pointer node.
+ *
+ * @return new hazard pointer node.
+ */
+ internal static inline unowned Node acquire () {
+ for (unowned Node? curr = get_head (); curr != null; curr = curr.get_next ())
+ if (curr.activate ())
+ return curr;
+ Node *node = new Node ();
+ Node *old_head = null;
+ do {
+ node->set_next (old_head = (Node *)AtomicPointer.get (&_head));
+ } while (!AtomicPointer.compare_and_exchange (&_head, old_head, node));
+ return node;
+ }
+
+ /**
+ * Tries to free from list.
+ *
+ * @return ``true`` if list is empty.
+ */
+ internal static bool try_free (ArrayList<FreeNode *> to_free) {
+ Collection<void *> used = new HashSet<void *>();
+ for (unowned Node? current = get_head (); current != null; current = current.get_next ()) {
+ used.add (current.get ());
+ }
+ for (int i = 0; i < to_free.size;) {
+ FreeNode *current = to_free[i];
+ if (used.contains (current->pointer)) {
+#if DEBUG
+ stderr.printf ("Skipping freeing %p\n", current->pointer);
+#endif
+ i++;
+ } else {
+#if DEBUG
+ stderr.printf ("Freeing %p\n", current->pointer);
+#endif
+ FreeNode *cur = to_free.remove_at (to_free.size - 1);
+ if (i != to_free.size) {
+ FreeNode *temp = to_free[i];
+ to_free[i] = cur;
+ cur = temp;
+ }
+ cur->destroy_notify (cur->pointer);
+ delete cur;
+ }
+ }
+ return to_free.size > 0;
+ }
+
+ /**
+ * Gets head of hazard pointers.
+ * @return Hazard pointer head.
+ */
+ internal static unowned Node? get_head () {
+ return (Node *)AtomicPointer.get(&_head);
+ }
+
+ internal unowned Node _node;
+
+ internal static Node *_head = null;
+
+ internal static int _default_policy = (int)Policy.TRY_FREE;
+ internal static int _thread_exit_policy = (int)Policy.RELEASE;
+
+ internal static int release_policy = 0;
+
+ internal static Queue<ArrayList<FreeNode *>> _queue;
+ internal static StaticMutex _queue_mutex;
+
+ internal static ArrayList<FreeNode *> _global_to_free;
+
+ internal static DestroyNotify get_destroy_notify<G> () {
+ return (ptr) => {
+ G *gptr = ptr;
+ G obj = (owned)gptr;
+ obj = null;
+ };
+ }
+
+ [Compact]
+ internal class FreeNode {
+ public void *pointer;
+ public DestroyNotify destroy_notify;
+ }
+
+ /**
+ * List of used pointers.
+ */
+ [Compact]
+ internal class Node {
+ public Node () {
+ AtomicPointer.set (&_hazard, null);
+ AtomicInt.set (ref _active, 1);
+ }
+
+ inline ~Node () {
+ delete _next;
+ }
+
+ public void release () {
+ AtomicPointer.set (&_hazard, null);
+ AtomicInt.set (ref _active, 0);
+ }
+
+ public inline bool is_active () {
+ return AtomicInt.get (ref _active) != 0;
+ }
+
+ public inline bool activate () {
+ return AtomicInt.compare_and_exchange (ref _active, 0, 1);
+ }
+
+ public inline void set (void *ptr) {
+ AtomicPointer.set (&_hazard, ptr);
+ }
+
+ public inline void *get (bool safe = true) {
+ if (safe) {
+ return (void *)AtomicPointer.get (&_hazard);
+ } else {
+ return (void *)_hazard;
+ }
+ }
+
+ public inline unowned Node? get_next () {
+ return (Node *)AtomicPointer.get (&_next);
+ }
+
+ public inline void set_next (Node *next) {
+ AtomicPointer.set (&_next, next);
+ }
+
+ public Node *_next;
+ public int _active;
+ public void *_hazard;
+ }
+}
+
diff --git a/gee/iterable.vala b/gee/iterable.vala
index b0097ac..67a302c 100644
--- a/gee/iterable.vala
+++ b/gee/iterable.vala
@@ -23,17 +23,15 @@
using GLib;
/**
- * Implemented by classes that support a simple iteration over instances of the
- * collection.
+ * An object that can provide an {@link Iterator}.
*/
-public abstract class Vala.Iterable<G> {
- public abstract Type get_element_type ();
-
+[GenericAccessors]
+public interface Vala.Iterable<G> : Object, Traversable<G> {
/**
- * Returns a Iterator that can be used for simple iteration over a
+ * Returns a {@link Iterator} that can be used for simple iteration over a
* collection.
*
- * @return a Iterator that can be used for simple iteration over a
+ * @return a {@link Iterator} that can be used for simple iteration over a
* collection
*/
public abstract Iterator<G> iterator ();
diff --git a/gee/iterator.vala b/gee/iterator.vala
index 5190fb6..8064e96 100644
--- a/gee/iterator.vala
+++ b/gee/iterator.vala
@@ -1,6 +1,8 @@
/* iterator.vala
*
* Copyright (C) 2007-2008 Jürg Billeter
+ * Copyright (C) 2009 Didier Villevalois, Maciej Piechotka
+ * Copyright (C) 2010-2011 Maciej Piechotka
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -18,25 +20,99 @@
*
* Author:
* Jürg Billeter <j bitron ch>
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
*/
/**
- * Implemented by classes that support a simple iteration over instances of the
- * collection.
+ * An iterator over a collection.
+ *
+ * Gee's iterators are "on-track" iterators. They always point to an item
+ * except before the first call to {@link next}, or, when an
+ * item has been removed, until the next call to {@link next}.
+ *
+ * Please note that when the iterator is out of track, neither {@link get} nor
+ * {@link remove} are defined and both will fail. After the next call to
+ * {@link next}, they will be defined again.
*/
-public abstract class Vala.Iterator<G> {
+public interface Vala.Iterator<G> : Object, Traversable<G> {
/**
* Advances to the next element in the iteration.
*
- * @return true if the iterator has a next element
+ * @return ``true`` if the iterator has a next element
*/
public abstract bool next ();
/**
+ * Checks whether there is a next element in the iteration.
+ *
+ * @return ``true`` if the iterator has a next element
+ */
+ public abstract bool has_next ();
+
+ /**
* Returns the current element in the iteration.
*
* @return the current element in the iteration
*/
- public abstract G? get ();
+ public abstract G get ();
+
+ /**
+ * Removes the current element in the iteration. The cursor is set in an
+ * in-between state. Both {@link get} and {@link remove} will fail until
+ * the next move of the cursor (calling {@link next}).
+ */
+ public abstract void remove ();
+
+ /**
+ * Determines wheather the call to {@link get} is legal. It is false at the
+ * beginning and after {@link remove} call and true otherwise.
+ */
+ public abstract bool valid { get; }
+
+ /**
+ * Determines wheather the call to {@link remove} is legal assuming the
+ * iterator is valid. The value must not change in runtime hence the user
+ * of iterator may cache it.
+ */
+ public abstract bool read_only { get; }
+
+ /**
+ * Create iterator from unfolding function. The lazy value is
+ * force-evaluated before progressing to next element.
+ *
+ * @param f Unfolding function
+ * @param current If iterator is to be valid it contains the current value of it
+ */
+ public static Iterator<A> unfold<A> (owned UnfoldFunc<A> f, owned Lazy<G>? current = null) {
+ return new UnfoldIterator<A> ((owned) f, (owned) current);
+ }
+
+ /**
+ * Concatinate iterators.
+ *
+ * @param iters Iterators of iterators
+ * @return Iterator containg values of each iterator
+ */
+ public static Iterator<G> concat<G> (Iterator<Iterator<G>> iters) {
+ Iterator<G>? current = null;
+ if (iters.valid)
+ current = iters.get ();
+ return unfold<G> (() => {
+ while (true) {
+ if (current == null) {
+ if (iters.next ()) {
+ current = iters.get ();
+ } else {
+ return null;
+ }
+ } else if (current.next ()) {
+ return new Lazy<G>.from_value (current.get ());
+ } else {
+ current = null;
+ }
+ }
+ });
+ }
}
diff --git a/gee/lazy.vala b/gee/lazy.vala
new file mode 100644
index 0000000..ed1ac3c
--- /dev/null
+++ b/gee/lazy.vala
@@ -0,0 +1,60 @@
+/* lazy.vala
+ *
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+namespace Vala {
+ public delegate G LazyFunc<G> ();
+}
+
+/**
+ * Represents a lazy value. I.e. value that is computed on demand.
+ */
+public class Vala.Lazy<G> {
+ public Lazy (owned LazyFunc<G> func) {
+ _func = (owned)func;
+ }
+
+ public Lazy.from_value (G item) {
+ _value = item;
+ }
+
+ public void eval () {
+ if (_func != null) {
+ _value = _func ();
+ _func = null;
+ }
+ }
+
+ public new G get () {
+ eval ();
+ return _value;
+ }
+
+ public new G value {
+ get {
+ eval ();
+ return _value;
+ }
+ }
+
+ private LazyFunc<G>? _func;
+ private G? _value;
+}
diff --git a/gee/linkedlist.vala b/gee/linkedlist.vala
new file mode 100644
index 0000000..16d82da
--- /dev/null
+++ b/gee/linkedlist.vala
@@ -0,0 +1,690 @@
+/* linkedlist.vala
+ *
+ * Copyright (C) 2004-2005 Novell, Inc
+ * Copyright (C) 2005 David Waite
+ * Copyright (C) 2007-2008 Jürg Billeter
+ * Copyright (C) 2009 Mark Lee, Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Mark Lee <marklee src gnome org>
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Doubly-linked list implementation of the {@link List} interface.
+ *
+ * This implementation is pretty well designed for highly mutable data. When
+ * indexed access is privileged prefer using {@link ArrayList}.
+ *
+ * @see ArrayList
+ */
+public class Vala.LinkedList<G> : AbstractBidirList<G>, Queue<G>, Deque<G> {
+ private int _size = 0;
+ private int _stamp = 0;
+ private Node<G>? _head = null;
+ private weak Node<G>? _tail = null;
+
+ /**
+ * The elements' equality testing function.
+ */
+ [CCode (notify = false)]
+ public EqualDataFunc<G> equal_func { private set; get; }
+
+ /**
+ * Constructs a new, empty linked list.
+ *
+ * If not provided, the function parameter is requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param equal_func an optional element equality testing function
+ */
+ public LinkedList (owned EqualDataFunc<G>? equal_func = null) {
+ if (equal_func == null) {
+ equal_func = Functions.get_equal_func_for (typeof (G));
+ }
+ this.equal_func = equal_func;
+ }
+
+ ~LinkedList () {
+ this.clear ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool foreach(ForallFunc<G> f) {
+ for (weak Node<G>? node = _head; node != null; node = node.next) {
+ if (!f (node.data)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.Iterator<G> iterator () {
+ return new Iterator<G> (this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override ListIterator<G> list_iterator () {
+ return new Iterator<G> (this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override BidirListIterator<G> bidir_list_iterator () {
+ return new Iterator<G> (this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int size {
+ get { return this._size; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool read_only {
+ get { return false; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool contains (G item) {
+ return this.index_of (item) != -1;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool add (G item) {
+ Node<G> n = new Node<G> (item);
+ if (this._head == null && this._tail == null) {
+ this._tail = n;
+ this._head = (owned) n;
+ } else {
+ n.prev = this._tail;
+ this._tail.next = (owned) n;
+ this._tail = this._tail.next;
+ }
+
+ // Adding items to the list during iterations is allowed.
+ //++this._stamp;
+
+ this._size++;
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool remove (G item) { // Should remove only the first occurence (a test should be
added)
+ for (weak Node<G> n = this._head; n != null; n = n.next) {
+ if (this.equal_func (item, n.data)) {
+ this._remove_node (n);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void clear () {
+ while (_head != null) {
+ _remove_node (_head);
+ }
+
+ ++this._stamp;
+ this._head = null;
+ this._tail = null;
+ this._size = 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G get (int index) {
+ assert (index >= 0);
+ assert (index < this._size);
+
+ unowned Node<G>? n = this._get_node_at (index);
+ assert (n != null);
+ return n.data;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void set (int index, G item) {
+ assert (index >= 0);
+ assert (index < this._size);
+
+ unowned Node<G>? n = this._get_node_at (index);
+ return_if_fail (n != null);
+ n.data = item;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int index_of (G item) {
+ int idx = 0;
+ for (weak Node<G>? node = _head; node != null; node = node.next, idx++) {
+ if (this.equal_func (item, node.data)) {
+ return idx;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void insert (int index, G item) {
+ assert (index >= 0);
+ assert (index <= this._size);
+
+ if (index == this._size) {
+ this.add (item);
+ } else {
+ Node<G> n = new Node<G> (item);
+ if (index == 0) {
+ n.next = (owned) this._head;
+ n.next.prev = n;
+ this._head = (owned)n;
+ } else {
+ weak Node prev = this._head;
+ for (int i = 0; i < index - 1; i++) {
+ prev = prev.next;
+ }
+ n.prev = prev;
+ n.next = (owned) prev.next;
+ n.next.prev = n;
+ prev.next = (owned) n;
+ }
+
+ // Adding items to the list during iterations is allowed.
+ //++this._stamp;
+
+ this._size++;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G remove_at (int index) {
+ assert (index >= 0);
+ assert (index < this._size);
+
+ unowned Node<G>? n = this._get_node_at (index);
+ assert (n != null);
+ G element = n.data;
+ this._remove_node (n);
+ return element;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override List<G>? slice (int start, int stop) {
+ return_val_if_fail (start <= stop, null);
+ return_val_if_fail (start >= 0, null);
+ return_val_if_fail (stop <= this._size, null);
+
+ List<G> slice = new LinkedList<G> (this.equal_func);
+ weak Node<G> n = this._get_node_at (start);
+ for (int i = start; i < stop; i++) {
+ slice.add (n.data);
+ n = n.next;
+ }
+
+ return slice;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G first () {
+ assert (_size > 0);
+ return _head.data;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G last () {
+ assert (_size > 0);
+ return _tail.data;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int capacity {
+ get { return UNBOUNDED_CAPACITY; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int remaining_capacity {
+ get { return UNBOUNDED_CAPACITY; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool is_full {
+ get { return false; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool offer (G element) {
+ return offer_tail (element);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? peek () {
+ return peek_head ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? poll () {
+ return poll_head ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int drain (Collection<G> recipient, int amount = -1) {
+ return drain_head (recipient, amount);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool offer_head (G element) {
+ insert (0, element);
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? peek_head () {
+ if (this._size == 0) {
+ return null;
+ }
+ return get (0);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? poll_head () {
+ if (this._size == 0) {
+ return null;
+ }
+ return remove_at (0);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int drain_head (Collection<G> recipient, int amount = -1) {
+ if (amount == -1) {
+ amount = this._size;
+ }
+ for (int i = 0; i < amount; i++) {
+ if (this._size == 0) {
+ return i;
+ }
+ recipient.add (remove_at (0));
+ }
+ return amount;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool offer_tail (G element) {
+ return add (element);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? peek_tail () {
+ if (this._size == 0) {
+ return null;
+ }
+ return get (_size - 1);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? poll_tail () {
+ if (this._size == 0) {
+ return null;
+ }
+ return remove_at (_size - 1);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int drain_tail (Collection<G> recipient, int amount = -1) {
+ if (amount == -1) {
+ amount = this._size;
+ }
+ for (int i = 0; i < amount; i++) {
+ if (this._size == 0) {
+ return i;
+ }
+ recipient.add (remove_at (this._size - 1));
+ }
+ return amount;
+ }
+
+ [Compact]
+ private class Node<G> { // Maybe a compact class should be used?
+ public G data;
+ public weak Node<G>? prev = null;
+ public Node<G>? next = null;
+ public Node (owned G data) {
+ this.data = data;
+ }
+ }
+
+ private class Iterator<G> : Object, Traversable<G>, Vala.Iterator<G>, BidirIterator<G>,
ListIterator<G>, BidirListIterator<G> {
+ private bool started = false;
+ private bool removed = false;
+ private unowned Node<G>? position;
+ private int _stamp;
+ private LinkedList<G> _list;
+ private int _index;
+
+ public Iterator (LinkedList<G> list) {
+ this._list = list;
+ this.position = null;
+ this._index = -1;
+ this._stamp = list._stamp;
+ }
+
+ public bool next () {
+ assert (this._stamp == this._list._stamp);
+
+ if (this.removed) {
+ if (this.position != null) {
+ this.removed = false;
+ return true;
+ } else {
+ return false;
+ }
+ } else if (!this.started) {
+ if (this._list._head != null) {
+ this.started = true;
+ this.position = this._list._head;
+ this._index++;
+ return true;
+ } else {
+ return false;
+ }
+ } else if (this.position != null) {
+ if (this.position.next != null) {
+ this.position = this.position.next;
+ this._index++;
+ return true;
+ } else {
+ return false;
+ }
+ }
+ return false;
+ }
+
+ public bool has_next () {
+ assert (this._stamp == this._list._stamp);
+
+ if (this.removed) {
+ return this.position != null;
+ } else if (!this.started) {
+ return this._list._head != null;
+ } else if (this.position != null) {
+ return this.position.next != null;
+ }
+ return false;
+ }
+
+ public bool first () {
+ assert (this._stamp == this._list._stamp);
+ if (this._list.size == 0) {
+ return false;
+ }
+ this.position = this._list._head;
+ this.started = true;
+ this._index = 0;
+ this.removed = false;
+ return this.position != null;
+ }
+
+ public new G get () {
+ assert (this._stamp == this._list._stamp);
+ assert (this.position != null);
+
+ return this.position.data;
+ }
+
+ public void remove () {
+ assert (this._stamp == this._list._stamp);
+ assert (this.position != null);
+
+ unowned Node<G>? new_position = this.position.next;
+ if (new_position == null) {
+ started = false;
+ }
+ _list._remove_node (this.position);
+ this.position = new_position;
+ this.removed = true;
+ this._stamp = this._list._stamp;
+ }
+
+ public bool previous () {
+ assert (this._stamp == this._list._stamp);
+
+ if (!this.started) {
+ this.position = null;
+ return false;
+ } else if (this.position != null && this.position.prev != null) {
+ this.position = this.position.prev;
+ this._index--;
+ return true;
+ }
+ return false;
+ }
+
+ public bool has_previous () {
+ assert (this._stamp == this._list._stamp);
+
+ if (!this.started) {
+ return false;
+ } else if (this.position != null) {
+ return this.position.prev != null;
+ }
+ return false;
+ }
+
+ public bool last () {
+ assert (this._stamp == this._list._stamp);
+
+ if (this._list.size == 0) {
+ return false;
+ }
+ this.position = this._list._tail;
+ this.started = true;
+ this._index = this._list._size - 1;
+ return this.position != null;
+ }
+
+ public new void set (G item) {
+ assert (this._stamp == this._list._stamp);
+ assert (this.position != null);
+
+ this.position.data = item;
+ }
+
+ public void insert (G item) {
+ assert (this._stamp == this._list._stamp);
+ assert (this.position != null);
+
+ Node<G> n = new Node<G> (item);
+ if (this.position.prev != null) {
+ Node<G> position = (owned) this.position.prev.next;
+ n.prev = position.prev;
+ position.prev = n;
+ n.next = (owned) position;
+ weak Node<G> _n = n;
+ _n.prev.next = (owned) n;
+ } else {
+ Node<G> position = (owned) this._list._head;
+ position.prev = n;
+ n.next = (owned) position;
+ this._list._head = (owned) n;
+ }
+ this._list._size++;
+ this._index++;
+ _stamp = _list._stamp;
+ }
+
+ public void add (G item) {
+ assert (this._stamp == this._list._stamp);
+ assert (this.position != null);
+
+ Node<G> n = new Node<G> (item);
+ if (this.position.next != null) {
+ this.position.next.prev = n;
+ n.next = (owned) this.position.next;
+ } else {
+ this._list._tail = n;
+ }
+ this.position.next = (owned) n;
+ this.position.next.prev = this.position;
+ this.position = this.position.next;
+ this._list._size++;
+ this._index++;
+ _stamp = _list._stamp;
+ }
+
+ public int index () {
+ assert (this._stamp == this._list._stamp);
+ assert (this.position != null);
+
+ return this._index;
+ }
+
+ public bool read_only {
+ get {
+ return false;
+ }
+ }
+
+ public bool valid {
+ get {
+ return !this.removed && this.position != null;
+ }
+ }
+
+ public bool foreach (ForallFunc<G> f) {
+ assert (_stamp == _list._stamp);
+ if (!started) {
+ position = _list._head;
+ if (position != null)
+ started = true;
+ }
+ removed = false;
+ while (position != null) {
+ if (!f (position.data)) {
+ return false;
+ }
+ position = position.next;
+ }
+ position = _list._tail;
+ return true;
+ }
+ }
+
+ private unowned Node<G>? _get_node_at (int index) {
+ unowned Node<G>? n = null;;
+ if (index == 0) {
+ n = this._head;
+ } else if (index == this._size - 1) {
+ n = this._tail;
+ } else if (index <= this._size / 2) {
+ n = this._head;
+ for (int i = 0; index != i; i++) {
+ n = n.next;
+ }
+ } else {
+ n = this._tail;
+ for (int i = this._size - 1; index != i; i--) {
+ n = n.prev;
+ }
+ }
+ return n;
+ }
+
+ private void _remove_node (Node<G> _n) {
+ Node<G> n;
+ weak Node<G> next;
+ if (_n == this._head) {
+ n = (owned) this._head;
+ next = this._head = (owned) n.next;
+ } else {
+ n = (owned) _n.prev.next;
+ next = n.prev.next = (owned) n.next;
+ }
+ if (n == this._tail) {
+ this._tail = n.prev;
+ } else {
+ next.prev = n.prev;
+ }
+ n.prev = null;
+ n.next = null;
+ n.data = null;
+ ++this._stamp;
+ this._size--;
+ }
+}
+
diff --git a/gee/list.vala b/gee/list.vala
index d730283..b99d598 100644
--- a/gee/list.vala
+++ b/gee/list.vala
@@ -21,9 +21,17 @@
*/
/**
- * Represents a collection of items in a well-defined order.
+ * An ordered collection.
*/
-public abstract class Vala.List<G> : Collection<G> {
+[GenericAccessors]
+public interface Vala.List<G> : Collection<G> {
+ /**
+ * Returns a ListIterator that can be used for iteration over this list.
+ *
+ * @return a ListIterator that can be used for iteration over this list
+ */
+ public abstract new ListIterator<G> list_iterator ();
+
/**
* Returns the item at the specified index in this list.
*
@@ -31,7 +39,7 @@ public abstract class Vala.List<G> : Collection<G> {
*
* @return the item at the specified index in the list
*/
- public abstract G? get (int index);
+ public abstract G get (int index);
/**
* Sets the item at the specified index in this list.
@@ -41,10 +49,10 @@ public abstract class Vala.List<G> : Collection<G> {
public abstract void set (int index, G item);
/**
- * Returns the index of the first occurrence of the specified item in
+ * Returns the index of the first occurence of the specified item in
* this list.
*
- * @return the index of the first occurrence of the specified item, or
+ * @return the index of the first occurence of the specified item, or
* -1 if the item could not be found
*/
public abstract int index_of (G item);
@@ -61,7 +69,77 @@ public abstract class Vala.List<G> : Collection<G> {
* Removes the item at the specified index of this list.
*
* @param index zero-based index of the item to be removed
+ *
+ * @return the removed element
+ */
+ public abstract G remove_at (int index);
+
+ /**
+ * Returns a slice of this list.
+ *
+ * @param start zero-based index of the begin of the slice
+ * @param stop zero-based index after the end of the slice
+ *
+ * @return A list containing a slice of this list
+ */
+ public abstract List<G>? slice (int start, int stop);
+
+ /**
+ * Returns the first item of the list. Fails if the list is empty.
+ *
+ * @return first item in the list
+ */
+ public virtual G first () {
+ return get (0);
+ }
+
+ /**
+ * Returns the last item of the list. Fails if the list is empty.
+ *
+ * @return last item in the list
+ */
+ public virtual G last () {
+ return get (size - 1);
+ }
+
+ /**
+ * Inserts items into this list for the input collection at the
+ * specified position.
+ *
+ * @param index zero-based index of the items to be inserted
+ * @param collection collection of items to be inserted
+ */
+ public virtual void insert_all (int index, Collection<G> collection) {
+ foreach (G item in collection) {
+ insert(index, item);
+ index++;
+ }
+ }
+
+ /**
+ * Sorts items by comparing with the specified compare function.
+ *
+ * @param compare_func compare function to use to compare items
+ */
+ public virtual void sort (owned CompareDataFunc<G>? compare_func = null) {
+ if (compare_func == null) {
+ compare_func = Functions.get_compare_func_for (typeof (G));
+ }
+ TimSort.sort<G> (this, compare_func);
+ }
+
+ /**
+ * The read-only view of this list.
+ */
+ public abstract new List<G> read_only_view { owned get; }
+
+ /**
+ * Returns an immutable empty list.
+ *
+ * @return an immutable empty list
*/
- public abstract void remove_at (int index);
+ public static List<G> empty<G> () {
+ return new LinkedList<G> ().read_only_view;
+ }
}
diff --git a/gee/listiterator.vala b/gee/listiterator.vala
new file mode 100644
index 0000000..a57a7df
--- /dev/null
+++ b/gee/listiterator.vala
@@ -0,0 +1,44 @@
+/* listiterator.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * A list iterator. This supports bi-directionnal and index-based iteration.
+ */
+public interface Vala.ListIterator<G> : Vala.Iterator<G> {
+ /**
+ * Sets the current item in the iteration to the specified new item.
+ */
+ public abstract void set (G item);
+
+ /**
+ * Adds the specified item after the current item in the iteration. The
+ * cursor is moved to point to the new added item.
+ */
+ public abstract void add (G item);
+
+ /**
+ * Returns the current index in the iteration.
+ *
+ * @return the current index
+ */
+ public abstract int index ();
+}
diff --git a/gee/map.vala b/gee/map.vala
index 2c96a3d..e48cb8a 100644
--- a/gee/map.vala
+++ b/gee/map.vala
@@ -21,43 +21,100 @@
*/
/**
- * A map is a generic collection of key/value pairs.
+ * An object that maps keys to values.
*/
-public abstract class Vala.Map<K,V> {
+[GenericAccessors]
+public interface Vala.Map<K,V> : Object, Iterable<Map.Entry<K,V>> {
/**
* The number of items in this map.
*/
public abstract int size { get; }
/**
- * Returns the keys of this map as a read-only set.
- *
- * @return the keys of the map
+ * Specifies whether this map is empty.
+ */
+ public virtual bool is_empty { get { return size == 0; } }
+
+ /**
+ * Specifies whether this collection can change - i.e. wheather {@link set},
+ * {@link remove} etc. are legal operations.
+ */
+ public abstract bool read_only { get; }
+
+ /**
+ * The read-only view of the keys of this map.
+ */
+ public abstract Set<K> keys { owned get; }
+
+ /**
+ * The read-only view of the values of this map.
*/
- public abstract Set<K> get_keys ();
+ public abstract Collection<V> values { owned get; }
+
+ /**
+ * The read-only view of the entries of this map.
+ */
+ public abstract Set<Entry<K,V>> entries { owned get; }
+
+ /**
+ * An entry of a map.
+ */
+ public abstract class Entry<K,V> : Object {
+ /**
+ * The key of this entry.
+ */
+ public abstract K key { get; }
+
+ /**
+ * The value of this entry.
+ */
+ public abstract V value { get; set; }
+
+ /**
+ * ``true'' if the setting value is permitted.
+ */
+ public abstract bool read_only { get; }
+ }
/**
- * Returns the values of this map as a read-only collection.
+ * Determines whether this map has the specified key.
*
- * @return the values of the map
+ * @param key the key to locate in the map
+ *
+ * @return ``true`` if key is found, ``false`` otherwise
*/
- public abstract Collection<V> get_values ();
+ public abstract bool has_key (K key);
/**
* Determines whether this map contains the specified key.
*
* @param key the key to locate in the map
*
- * @return true if key is found, false otherwise
+ * @return ``true`` if key is found, ``false`` otherwise
+ *
+ * @deprecated Use {@link has_key} method instead.
+ */
+ [Version (deprecated = true)]
+ public bool contains (K key) {
+ return has_key(key);
+ }
+
+ /**
+ * Determines whether this map has the specified key/value entry.
+ *
+ * @param key the key to locate in the map
+ * @param value the corresponding value
+ *
+ * @return ``true`` if key is found, ``false`` otherwise
*/
- public abstract bool contains (K key);
+ public abstract bool has (K key, V value);
/**
* Returns the value of the specified key in this map.
*
* @param key the key whose value is to be retrieved
*
- * @return the value associated with the key, or null if the key
+ * @return the value associated with the key, or ``null`` if the key
* couldn't be found
*/
public abstract V? get (K key);
@@ -73,11 +130,27 @@ public abstract class Vala.Map<K,V> {
/**
* Removes the specified key from this map.
*
- * @param key the key to remove from the map
+ * @param key the key to remove from the map
+ * @param value the receiver variable for the removed value
*
- * @return true if the map has been changed, false otherwise
+ * @return ``true`` if the map has been changed, ``false`` otherwise
*/
- public abstract bool remove (K key);
+ public abstract bool unset (K key, out V? value = null);
+
+ /**
+ * Removes the specified key from this map.
+ *
+ * @param key the key to remove from the map
+ * @param value the receiver variable for the removed value
+ *
+ * @return ``true`` if the map has been changed, ``false`` otherwise
+ *
+ * @deprecated Use {@link unset} method instead.
+ */
+ [Version (deprecated = true)]
+ public bool remove (K key, out V? value = null) {
+ return unset (key, out value);
+ }
/**
* Removes all items from this collection. Must not be called on
@@ -86,12 +159,98 @@ public abstract class Vala.Map<K,V> {
public abstract void clear ();
/**
- * Returns a Iterator that can be used for simple iteration over a
- * map.
+ * Returns an iterator for this map.
*
- * @return a Iterator that can be used for simple iteration over a
- * map
+ * @return a map iterator
*/
public abstract MapIterator<K,V> map_iterator ();
+
+ /**
+ * Inserts all items that are contained in the input map to this map.
+ *
+ * @param map the map which items are inserted to this map
+ */
+ public virtual void set_all (Map<K,V> map) {
+ foreach (Map.Entry<K,V> entry in map.entries) {
+ set (entry.key, entry.value);
+ }
+ }
+
+ /**
+ * Removes all items from this map that are common to the input map
+ * and this map.
+ *
+ * @param map the map which common items are deleted from this map
+ */
+ public virtual bool unset_all (Map<K,V> map) {
+ bool changed = false;
+ foreach (K key in map.keys) {
+ changed = changed | unset (key);
+ }
+ return changed;
+ }
+
+ /**
+ * Removes all items from this map that are common to the input map
+ * and this map.
+ *
+ * @param map the map which common items are deleted from this map
+ *
+ * @deprecated Use {@link unset_all} method instead.
+ */
+ [Version (deprecated = true)]
+ public bool remove_all (Map<K,V> map) {
+ return unset_all (map);
+ }
+
+ /**
+ * Returns ``true`` it this map contains all items as the input map.
+ *
+ * @param map the map which items will be compared with this map
+ */
+ public virtual bool has_all (Map<K,V> map) {
+ foreach (Map.Entry<K,V> entry in map.entries) {
+ if (!has (entry.key, entry.value)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Returns ``true`` it this map contains all items as the input map.
+ *
+ * @param map the map which items will be compared with this map
+ *
+ * @deprecated Use {@link has_all} method instead.
+ */
+ [Version (deprecated = true)]
+ public bool contains_all (Map<K,V> map) {
+ return has_all (map);
+ }
+
+ /**
+ * The read-only view this map.
+ */
+ public abstract Map<K,V> read_only_view { owned get; }
+
+ /**
+ * The type of the keys in this map.
+ */
+ public Type key_type { get { return typeof(K); } }
+
+ /**
+ * The type of the values in this map.
+ */
+ public Type value_type { get { return typeof(V); } }
+
+ /**
+ * Returns an immutable empty map.
+ *
+ * @return an immutable empty map
+ */
+ public static Map<K,V> empty<K,V> () {
+ return new HashMap<K,V> ().read_only_view;
+ }
}
diff --git a/gee/mapiterator.vala b/gee/mapiterator.vala
index 78243c2..2ad5890 100644
--- a/gee/mapiterator.vala
+++ b/gee/mapiterator.vala
@@ -1,6 +1,7 @@
/* mapiterator.vala
*
- * Copyright (C) 2011 Florian Brosch
+ * Copyright (C) 2009 Didier Villevalois
+ * Copyright (C) 2011 Maciej Piechotka
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -17,23 +18,43 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Author:
- * Florian Brosch <flo brosch gmail com>
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
*/
-
+namespace Vala {
+ public delegate A FoldMapFunc<A, K, V> (K k, V v, owned A a);
+ public delegate bool ForallMapFunc<K, V> (K k, V v);
+}
/**
* An iterator over a map.
+ *
+ * Gee's iterators are "on-track" iterators. They always point to an item
+ * except before the first call to {@link next}, or, when an
+ * item has been removed, until the next call to {@link next}.
+ *
+ * Please note that when the iterator is out of track, neither {@link get_key},
+ * {@link get_value}, {@link set_value} nor {@link unset} are defined and all
+ * will fail. After the next call to {@link next}, they will
+ * be defined again.
*/
-public abstract class Vala.MapIterator<K,V> {
+[GenericAccessors]
+public interface Vala.MapIterator<K,V> : Object {
/**
- * Advances to the next element in the iteration.
+ * Advances to the next entry in the iteration.
*
- * @return true if the iterator has a next element
+ * @return ``true`` if the iterator has a next entry
*/
public abstract bool next ();
/**
+ * Checks whether there is a next entry in the iteration.
+ *
+ * @return ``true`` if the iterator has a next entry
+ */
+ public abstract bool has_next ();
+
+ /**
* Returns the current key in the iteration.
*
* @return the current key in the iteration
@@ -41,12 +62,84 @@ public abstract class Vala.MapIterator<K,V> {
public abstract K get_key ();
/**
- * Returns the current value in the iteration.
+ * Returns the value associated with the current key in the iteration.
*
- * @return the current value in the iteration
+ * @return the value for the current key
*/
public abstract V get_value ();
-}
+ /**
+ * Sets the value associated with the current key in the iteration.
+ *
+ * @param value the new value for the current key
+ */
+ public abstract void set_value (V value);
+
+ /**
+ * Unsets the current entry in the iteration. The cursor is set in an
+ * in-between state. {@link get_key}, {@link get_value}, {@link set_value}
+ * and {@link unset} will fail until the next move of the cursor (calling
+ * {@link next}).
+ */
+ public abstract void unset ();
+ /**
+ * Determines wheather the call to {@link get_key}, {@link get_value} and
+ * {@link set_value} is legal. It is false at the beginning and after
+ * {@link unset} call and true otherwise.
+ */
+ public abstract bool valid { get; }
+
+ /**
+ * Determines wheather the call to {@link set_value} is legal assuming the
+ * iterator is valid. The value must not change in runtime hence the user
+ * of iterator may cache it.
+ */
+ public abstract bool mutable { get; }
+
+ /**
+ * Determines wheather the call to {@link unset} is legal assuming the
+ * iterator is valid. The value must not change in runtime hence the user
+ * of iterator may cache it.
+ */
+ public abstract bool read_only { get; }
+
+ /**
+ * Standard aggragation function.
+ *
+ * It takes a function, seed and first element, returns the new seed and
+ * progress to next element when the operation repeats.
+ *
+ * Operation moves the iterator to last element in iteration. If iterator
+ * points at some element it will be included in iteration.
+ */
+ public virtual A fold<A> (FoldMapFunc<A, K, V> f, owned A seed)
+ {
+ if (valid)
+ seed = f (get_key (), get_value (), (owned) seed);
+ while (next ())
+ seed = f (get_key (), get_value (), (owned) seed);
+ return (owned) seed;
+ }
+
+ /**
+ * Apply function to each element returned by iterator.
+ *
+ * Operation moves the iterator to last element in iteration. If iterator
+ * points at some element it will be included in iteration.
+ */
+ public new virtual bool foreach (ForallMapFunc<K, V> f) {
+ if (valid) {
+ if (!f (get_key (), get_value ())) {
+ return false;
+ }
+ }
+ while (next ()) {
+ if (!f (get_key (), get_value ())) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
diff --git a/gee/multimap.vala b/gee/multimap.vala
new file mode 100644
index 0000000..6c1748b
--- /dev/null
+++ b/gee/multimap.vala
@@ -0,0 +1,127 @@
+/* multimap.vala
+ *
+ * Copyright (C) 2009 Ali Sabil
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Ali Sabil <ali sabil gmail com>
+ */
+
+/**
+ * A map with multiple values per key.
+ */
+[GenericAccessors]
+public interface Vala.MultiMap<K,V> : Object {
+ /**
+ * The number of key/value pairs in this map.
+ */
+ public abstract int size { get; }
+
+ /**
+ * Specifies whether this collection can change - i.e. wheather {@link set},
+ * {@link remove} etc. are legal operations.
+ */
+ public abstract bool read_only { get; }
+
+ /**
+ * Returns the keys of this multimap as a read-only set.
+ *
+ * @return the keys of the map
+ */
+ public abstract Set<K> get_keys ();
+
+ /**
+ * Returns the keys of this multimap as a read-only set.
+ *
+ * @return the keys of the map
+ */
+ public abstract MultiSet<K> get_all_keys ();
+
+ /**
+ * Returns the values of this map as a read-only collection.
+ *
+ * @return the values of the map
+ */
+ public abstract Collection<V> get_values ();
+
+ /**
+ * Determines whether this map contains the specified key.
+ *
+ * @param key the key to locate in the map
+ *
+ * @return ``true`` if key is found, ``false`` otherwise
+ */
+ public abstract bool contains (K key);
+
+ /**
+ * Returns the values for the specified key in this map.
+ *
+ * @param key the key whose values are to be retrieved
+ *
+ * @return a Collection of values associated with the given key
+ */
+ public abstract Collection<V> get (K key);
+
+ /**
+ * Inserts a key/value pair into this map.
+ *
+ * @param key the key to insert
+ * @param value the value to associate with the key
+ */
+ public abstract void set (K key, V value);
+
+ /**
+ * Removes the specified key/value pair from this multimap.
+ *
+ * @param key the key to remove from the map
+ * @param value the value to remove from the map
+ *
+ * @return ``true`` if the map has been changed, ``false`` otherwise
+ */
+ public abstract bool remove (K key, V value);
+
+ /**
+ * Removes the specified key and all the associated values from this
+ * multimap.
+ *
+ * @param key the key to remove from the map
+ *
+ * @return ``true`` if the map has been changed, ``false`` otherwise
+ */
+ public abstract bool remove_all (K key);
+
+ /**
+ * Removes all items from this collection.
+ */
+ public abstract void clear ();
+
+ /**
+ * Returns an iterator for this map.
+ *
+ * @return a map iterator
+ */
+ public abstract MapIterator<K, V> map_iterator ();
+
+ /**
+ * The type of the keys in this multimap.
+ */
+ public Type key_type { get { return typeof (K); } }
+
+ /**
+ * The type of the values in this multimap.
+ */
+ public Type value_type { get { return typeof (V); } }
+}
diff --git a/gee/multiset.vala b/gee/multiset.vala
new file mode 100644
index 0000000..7b9f774
--- /dev/null
+++ b/gee/multiset.vala
@@ -0,0 +1,36 @@
+/* multiset.vala
+ *
+ * Copyright (C) 2009 Ali Sabil
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Ali Sabil <ali sabil gmail com>
+ */
+
+/**
+ * A collection with duplicate elements.
+ */
+[GenericAccessors]
+public interface Vala.MultiSet<G> : Collection<G> {
+ /**
+ * Returns the number of occurences of an item in this multiset.
+ *
+ * @param item the item to count occurences of
+ *
+ * @return the number of occurences of the item in this multiset.
+ */
+ public abstract int count (G item);
+}
diff --git a/gee/priorityqueue.vala b/gee/priorityqueue.vala
new file mode 100644
index 0000000..04d0a00
--- /dev/null
+++ b/gee/priorityqueue.vala
@@ -0,0 +1,1207 @@
+/* priorityqueue.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ * Copyright (C) 2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Relaxed fibonacci heap priority queue implementation of the {@link Queue}.
+ *
+ * The elements of the priority queue are ordered according to their natural
+ * ordering, or by a compare_func provided at queue construction time. A
+ * priority queue does not permit null elements and does not have bounded
+ * capacity.
+ *
+ * This implementation provides O(1) time for offer and peek methods, and
+ * O(log n) for poll method. It is based on the algorithms described by
+ * Boyapati Chandra Sekhar in:
+ *
+ * "Worst Case Efficient Data Structures
+ * for Priority Queues and Deques with Heap Order"
+ * Boyapati Chandra Sekhar (under the guidance of Prof. C. Pandu Rangan)
+ * Department of Computer Science and Engineering
+ * Indian Institute of Technology, Madras
+ * May 1996
+ */
+public class Vala.PriorityQueue<G> : Vala.AbstractQueue<G> {
+
+ /**
+ * The elements' comparator function.
+ */
+ [CCode (notify = false)]
+ public CompareDataFunc<G> compare_func { private set; get; }
+
+ private int _size = 0;
+ private int _stamp = 0;
+ private Type1Node<G>? _r = null;
+ private Type2Node<G>? _r_prime = null;
+ private Type2Node<G>? _lm_head = null;
+ private Type2Node<G>? _lm_tail = null;
+ private Type1Node<G>? _p = null;
+ private Type1Node<G>?[] _a = new Type1Node<G>?[0];
+ private NodePair<G>? _lp_head = null;
+ private NodePair<G>? _lp_tail = null;
+ private bool[] _b = new bool[0];
+ private Type1Node<G>? _ll_head = null;
+ private Type1Node<G>? _ll_tail = null;
+ private unowned Node<G> _iter_head = null;
+ private unowned Node<G> _iter_tail = null;
+
+ /**
+ * Constructs a new, empty priority queue.
+ *
+ * If not provided, the function parameter is requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param compare_func an optional element comparator function
+ */
+ public PriorityQueue (owned CompareDataFunc<G>? compare_func = null) {
+ if (compare_func == null) {
+ compare_func = Functions.get_compare_func_for (typeof (G));
+ }
+ this.compare_func = compare_func;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int capacity {
+ get { return UNBOUNDED_CAPACITY; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int remaining_capacity {
+ get { return UNBOUNDED_CAPACITY; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool is_full {
+ get { return false; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool read_only {
+ get { return false; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool offer (G element) {
+ #if DEBUG
+ _dump ("Start offer: %s".printf ((string)element));
+ #endif
+ if (_r == null) {
+ _r = new Type1Node<G> (element, ref _iter_head, ref _iter_tail);
+ _p = _r;
+ } else if (_r_prime == null) {
+ _r_prime = new Type2Node<G> (element, ref _iter_head, ref _iter_tail);
+ _r_prime.parent = _r;
+ _r.type2_child = _r_prime;
+ if (_compare (_r_prime, _r) < 0)
+ _swap_data (_r_prime, _r);
+ } else {
+ // Form a tree with a single node N of type I consisting of element e
+ Type1Node<G> node = new Type1Node<G> (element, ref _iter_head, ref _iter_tail);
+
+ //Add(Q, N)
+ _add (node);
+ }
+
+ _stamp++;
+ _size++;
+ #if DEBUG
+ _dump ("End offer: %s".printf ((string)element));
+ #endif
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? peek () {
+ if (_r == null) {
+ return null;
+ }
+ return _r.data;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? poll () {
+ #if DEBUG
+ _dump ("Start poll:");
+ #endif
+
+ // 1a. M inElement <- R.element
+ if (_r == null) {
+ return null;
+ }
+ G min = _r.data;
+ _r.pending_drop = false;
+ _stamp++;
+ _size--;
+
+ // 1b. R.element = R'.element
+ if (_r_prime == null) {
+ if (_r.iter_next != null) {
+ _r.iter_next.iter_prev = _r.iter_prev;
+ }
+ if (_r.iter_prev != null) {
+ _r.iter_prev.iter_next = _r.iter_next;
+ }
+ if (_iter_head == _r) {
+ _iter_head = _r.iter_next;
+ }
+ if (_iter_tail == _r) {
+ _iter_tail = _r.iter_prev;
+ }
+ _r = null;
+ _p = null;
+ return min;
+ }
+ _move_data (_r, _r_prime);
+
+
+ // 1c. R'' <- The child of R' containing the minimum element among the children of R'
+ if (_r_prime.type1_children_head == null) {
+ _remove_type2_node (_r_prime, true);
+ _r_prime = null;
+ return min;
+ }
+ Type1Node<G>? r_second = null;
+ Type1Node<G> node = _r_prime.type1_children_head;
+ while (node != null) {
+ if (r_second == null || _compare (node, r_second) < 0) {
+ r_second = node;
+ }
+ node = node.brothers_next;
+ }
+
+ // 1d. R'.element <- R''.element
+ _move_data (_r_prime, r_second);
+
+ // 2a. Delete the subtree rooted at R'' from Q
+ _remove_type1_node (r_second, true);
+
+ // 2b. For all children N of type I of R'' do make N a child of R' of Q
+ node = r_second.type1_children_head;
+ while (node != null) {
+ Type1Node<G> next = node.brothers_next;
+ _remove_type1_node (node, false);
+ _add_in_r_prime (node);
+ node = next;
+ }
+
+ // For now we can't have type2 node other than R' (left for reference)
+ #if false
+ // 3a. If R'' has no child of type II then goto Step 4.
+ if (r_second.type2_child != null) {
+ // 3b. Let M' be the child of type II of R''. Insert(Q, M'.element)
+ Type2Node<G> m_prime = r_second.type2_child;
+ _remove_type2_node (m_prime);
+ offer (m_prime.data);
+
+ // 3c. For all children N of M do make N a child of R' of Q
+ node = m_prime.type1_children_head;
+ while (node != null) {
+ Type1Node<G> next = node.brothers_next;
+ _remove_type1_node (node);
+ _add_in_r_prime (node);
+ node = next;
+ }
+ }
+ #endif
+
+ // 4. Adjust(Q, P, P)
+ _adjust (_p, _p);
+
+ // For now we can't have type2 node other than R' (left for reference)
+ #if false
+ // 5a. if LM is empty then goto Step 6
+ if (_lm_head != null) {
+ // 5b. M <- Head(LM); LM <- Tail(LM)
+ Type2Node<G> m = _lm_head;
+
+ // 5c. Delete M from Q
+ _remove_type2_node (m);
+
+ // 5d. I nsert(Q, M.element)
+ offer (m.data);
+
+ // 5e. For all children N of M do make M a child of R' of Q
+ node = m.type1_children_head;
+ while (node != null) {
+ Type1Node<G> next = node.brothers_next;
+ _remove_type1_node (node);
+ _add_in_r_prime (node);
+ node = next;
+ }
+ }
+ #endif
+
+ // 6. While among the children of R' there exist any two different nodes Ri and Rj
+ // such that Ri.degree = Rj.degree do Link(Q, Ri, Rj)
+ while (_check_linkable ()) {}
+
+ // 7. Return MinElement
+ return min;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int drain (Collection<G> recipient, int amount = -1) {
+ if (amount == -1) {
+ amount = this._size;
+ }
+ for (int i = 0; i < amount; i++) {
+ if (this._size == 0) {
+ return i;
+ }
+ recipient.add (poll ());
+ }
+ return amount;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override int size {
+ get { return _size; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool contains (G item) {
+ foreach (G an_item in this) {
+ if (compare_func (item, an_item) == 0) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool add (G item) {
+ return offer (item);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool remove (G item) {
+ #if DEBUG
+ _dump ("Start remove: %s".printf ((string) item));
+ #endif
+
+ Iterator<G> iterator = new Iterator<G> (this);
+ while (iterator.next ()) {
+ G an_item = iterator.get ();
+ if (compare_func (item, an_item) == 0) {
+ iterator.remove ();
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void clear () {
+ _size = 0;
+ _r = null;
+ _r_prime = null;
+ _lm_head = null;
+ _lm_tail = null;
+ _p = null;
+ _a = new Type1Node<G>?[0];
+ _lp_head = null;
+ _lp_tail = null;
+ _b = new bool[0];
+ _ll_head = null;
+ _ll_tail = null;
+ _iter_head = null;
+ _iter_tail = null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.Iterator<G> iterator () {
+ return new Iterator<G> (this);
+ }
+
+ private inline int _compare (Node<G> node1, Node<G> node2) {
+ // Assume there can't be two nodes pending drop
+ if (node1.pending_drop) {
+ return -1;
+ } else if (node2.pending_drop) {
+ return 1;
+ } else {
+ return compare_func (node1.data, node2.data);
+ }
+ }
+
+ private inline void _swap_data (Node<G> node1, Node<G> node2) {
+ #if DEBUG
+ _dump ("Before swap: %p(%s) %p(%s)".printf(node1, (string)node1.data, node2,
(string)node2.data));
+ #endif
+ G temp_data = (owned) node1.data;
+ bool temp_pending_drop = node1.pending_drop;
+ node1.data = (owned) node2.data;
+ node1.pending_drop = node2.pending_drop;
+ node2.data = (owned) temp_data;
+ node2.pending_drop = temp_pending_drop;
+
+ if (node1.iter_next == node2) { // Before swap: N1 N2
+ unowned Node<G> temp_iter_prev = node1.iter_prev;
+ unowned Node<G> temp_iter_next = node2.iter_next;
+
+ node1.iter_prev = node2;
+ node1.iter_next = temp_iter_next;
+ node2.iter_prev = temp_iter_prev;
+ node2.iter_next = node1;
+ } else if (node1.iter_prev == node2) { // Before swap: N2 N1
+ unowned Node<G> temp_iter_prev = node2.iter_prev;
+ unowned Node<G> temp_iter_next = node1.iter_next;
+
+ node1.iter_prev = temp_iter_prev;
+ node1.iter_next = node2;
+ node2.iter_prev = node1;
+ node2.iter_next = temp_iter_next;
+ } else {
+ unowned Node<G> temp_iter_prev = node1.iter_prev;
+ unowned Node<G> temp_iter_next = node1.iter_next;
+
+ node1.iter_prev = node2.iter_prev;
+ node1.iter_next = node2.iter_next;
+ node2.iter_prev = temp_iter_prev;
+ node2.iter_next = temp_iter_next;
+ }
+
+ if (node2 == _iter_head) {
+ _iter_head = node1;
+ } else if (node1 == _iter_head) {
+ _iter_head = node2;
+ }
+ if (node2 == _iter_tail) {
+ _iter_tail = node1;
+ } else if (node1 == _iter_tail) {
+ _iter_tail = node2;
+ }
+
+ if (node1.iter_prev != null) {
+ node1.iter_prev.iter_next = node1;
+ }
+ if (node1.iter_next != null) {
+ node1.iter_next.iter_prev = node1;
+ }
+ if (node2.iter_prev != null) {
+ node2.iter_prev.iter_next = node2;
+ }
+ if (node2.iter_next != null) {
+ node2.iter_next.iter_prev = node2;
+ }
+
+ #if DEBUG
+ _dump ("After swap: %p(%s) %p(%s)".printf(node1, (string)node1.data, node2,
(string)node2.data));
+ #endif
+ }
+
+ private inline void _move_data (Node<G> target, Node<G> source) {
+ #if DEBUG
+ _dump ("Before move: %p(%s) <- %p(%s)".printf(target, (string)target.data, source,
(string)source.data));
+ #endif
+
+ if (target.iter_next != null) {
+ target.iter_next.iter_prev = target.iter_prev;
+ } else if (_iter_tail == target) {
+ _iter_tail = target.iter_prev;
+ }
+ if (target.iter_prev != null) {
+ target.iter_prev.iter_next = target.iter_next;
+ } else if (_iter_head == target) {
+ _iter_head = target.iter_next;
+ }
+
+ target.data = source.data;
+ target.pending_drop = source.pending_drop;
+ target.iter_next = source.iter_next;
+ target.iter_prev = source.iter_prev;
+ source.iter_next = null;
+ source.iter_prev = null;
+
+ if (target.iter_next != null) {
+ target.iter_next.iter_prev = target;
+ } else if (_iter_tail == source) {
+ _iter_tail = target;
+ }
+ if (target.iter_prev != null) {
+ target.iter_prev.iter_next = target;
+ } else if (_iter_head == source) {
+ _iter_head = target;
+ }
+ #if DEBUG
+ _dump ("After move:");
+ #endif
+ }
+
+ private void _link (owned Type1Node<G> ri, owned Type1Node<G> rj) {
+ assert (ri.degree () == rj.degree ());
+
+ // Delete the subtrees rooted at Ri and Rj from Q
+ _remove_type1_node (ri, false);
+ _remove_type1_node (rj, false);
+
+ // If Ri.element > Rj.element then Swap(Ri,Rj)
+ if (_compare (ri, rj) > 0) {
+ Type1Node<G> temp = ri;
+ ri = rj;
+ rj = temp;
+ }
+
+ // Make Rj the last child of Ri
+ _add_to (rj, ri);
+
+ // Make Ri (whose degree now = d+1) a child of R' of Q
+ _add_in_r_prime (ri);
+ }
+
+ private void _add (Type1Node<G> n) {
+ // Make N a child of R' of Q
+ _add_in_r_prime (n);
+
+ // If N.element < R'.element then Swap(N.element, R'.element)
+ if (_compare (n, _r_prime) < 0) {
+ _swap_data (n, _r_prime);
+ }
+
+ // If R'.element < R.element then Swap(R'.element, R.element)
+ if (_compare (_r_prime, _r) < 0) {
+ _swap_data (_r_prime, _r);
+ }
+
+ // If among the children of R' there exist any two different nodes Ri and Rj
+ // such that Ri.degree = Rj.degree then Link(Q, Ri, Rj)
+ _check_linkable ();
+
+ #if DEBUG
+ _dump ("End _add: %p(%s)".printf (n, (string) n.data));
+ #endif
+ }
+
+ private bool _check_linkable () {
+ #if DEBUG
+ _dump ("Start _check_linkable:");
+ #endif
+
+ if (_lp_head != null) {
+ NodePair<G> pair = _lp_head;
+ _link (pair.node1, pair.node2);
+ return true;
+ }
+ return false;
+ }
+
+ private Node<G> _re_insert (owned Type1Node<G> n) {
+ assert (n != _r);
+
+ #if DEBUG
+ _dump ("Start _re_insert: %p(%s)".printf (n, (string) n.data));
+ #endif
+
+ //Parent <- N.parent
+ Node<G> parent = n.parent;
+
+ // Delete the subtree rooted at N from Q
+ _remove_type1_node (n, false);
+
+ // Add(Q, N)
+ _add (n);
+
+ // Return Parent
+ return parent;
+ }
+
+ private void _adjust (Type1Node<G> p1, Type1Node<G> p2) {
+ // If M.lost <= 1 for all nodes M in Q then return
+ if (_ll_head == null) {
+ return;
+ }
+
+ #if DEBUG
+ _dump ("Start _adjust: %p(%s), %p(%s)".printf (p1, (string) p1.data, p2, (string)
p2.data));
+ #endif
+
+ // If P1.lost > P2.lost then M <- P1 else M <- P2
+ Type1Node<G> m;
+ if (p1.lost > p2.lost) {
+ m = p1;
+ } else {
+ m = p2;
+ }
+
+ // If M.lost <= 1 then M <- M' for some node M' in Q such that M'.lost > 1
+ if (m.lost <= 1) {
+ m = _ll_head;
+ if (_ll_head.ll_next != null) {
+ _ll_head.ll_next.ll_prev = null;
+ }
+ _ll_head = _ll_head.ll_next;
+ }
+
+ // P <- ReInsert(Q, M)
+ _p = (Type1Node<G>) _re_insert (m);
+
+ #if DEBUG
+ _dump ("End _adjust: %p(%s), %p(%s)".printf (p1, (string) p1.data, p2, (string)
p2.data));
+ #endif
+ }
+
+ private void _delete (Node<G> n) {
+ // DecreaseKey(Q, N, infinite)
+ _decrease_key (n);
+
+ // DeleteMin(Q)
+ poll ();
+ }
+
+ private void _decrease_key (Node<G> n) {
+ #if DEBUG
+ _dump ("Start _decrease_key: %p(%s)".printf (n, (string) n.data));
+ #endif
+
+ if (n == _r || _r_prime == null) {
+ return;
+ }
+
+ n.pending_drop = true;
+
+ // If (N = R or R') and (R'.element < R.element) then
+ // Swap(R'.element, R.element); return
+ if (n == _r_prime && _compare (_r_prime, _r) < 0) {
+ _swap_data (_r_prime, _r);
+ return;
+ }
+
+ // For now we can't have type2 node other than R' (left for reference)
+ #if false
+ // If (N is of type II) and (N.element < N.parent.element) then
+ // Swap(N.element, N.parent.element); N <- N.parent
+ if (n is Type2Node && _compare (n, n.parent) < 0) {
+ _swap_data (n, n.parent);
+ n = n.parent;
+ }
+ #endif
+
+ // Can't occur as we made n be the most little (left for reference)
+ #if false
+ // If N.element >= N.parent.element then return
+ if (n.parent != null && _compare (n, n.parent) >= 0) {
+ return;
+ }
+ #endif
+
+ // P' <- ReInsert(Q, N)
+ Node<G> p_prime = _re_insert ((Type1Node<G>) n);
+
+ if (p_prime is Type2Node) {
+ // Adjust(Q, P, P);
+ _adjust (_p, _p);
+ } else {
+ // Adjust(Q, P, P');
+ _adjust (_p, (Type1Node<G>) p_prime);
+ }
+ }
+
+ private void _add_to (Type1Node<G> node, Type1Node<G> parent) {
+ parent.add (node);
+ parent.lost = 0;
+ }
+
+ private void _add_in_r_prime (Type1Node<G> node) {
+ #if DEBUG
+ _dump ("Start _add_in_r_prime: %p(%s)".printf (node, (string) node.data));
+ #endif
+
+ int degree = node.degree ();
+
+ Type1Node<G>? insertion_point = null;
+ if (degree < _a.length) {
+ insertion_point = _a[degree];
+ }
+
+ if (insertion_point == null) {
+ if (_r_prime.type1_children_tail != null) {
+ node.brothers_prev = _r_prime.type1_children_tail;
+ _r_prime.type1_children_tail.brothers_next = node;
+ } else {
+ _r_prime.type1_children_head = node;
+ }
+ _r_prime.type1_children_tail = node;
+ } else {
+ if (insertion_point.brothers_prev != null) {
+ insertion_point.brothers_prev.brothers_next = node;
+ node.brothers_prev = insertion_point.brothers_prev;
+ } else {
+ _r_prime.type1_children_head = node;
+ }
+ node.brothers_next = insertion_point;
+ insertion_point.brothers_prev = node;
+ }
+ node.parent = _r_prime;
+
+ // Maintain A, B and LP
+ if (degree >= _a.length) {
+ _a.resize (degree + 1);
+ _b.resize (degree + 1);
+ }
+
+ // If there is already a child of such degree
+ if (_a[degree] == null) {
+ _b[degree] = true;
+ } else {
+ // Else if there is an odd number of child of such degree
+ if (_b[degree]) {
+ // Make a pair
+ NodePair<G> pair = new NodePair<G> (node, node.brothers_next);
+ node.brothers_next.pair = pair;
+ node.pair = pair;
+ if (_lp_head == null) {
+ _lp_head = pair;
+ _lp_tail = pair;
+ } else {
+ pair.lp_prev = _lp_tail;
+ _lp_tail.lp_next = pair;
+ _lp_tail = pair;
+ }
+ // There is now an even number of child of such degree
+ _b[degree] = false;
+ } else {
+ _b[degree] = true;
+ }
+ }
+ _a[degree] = node;
+
+ #if DEBUG
+ _dump ("End _add_in_r_prime: %p(%s)".printf (node, (string) node.data));
+ #endif
+ }
+
+ private void _remove_type1_node (Type1Node<G> node, bool with_iteration) {
+ #if DEBUG
+ _dump ("Start _remove_type1_node: %p(%s)".printf (node, (string) node.data));
+ #endif
+
+ if (node.parent == _r_prime) {
+ _updated_degree (node, false);
+ } else {
+ // Maintain LL
+ if (node.ll_prev != null) {
+ node.ll_prev.ll_next = node.ll_next;
+ } else if (_ll_head == node) {
+ _ll_head = node.ll_next;
+ }
+ if (node.ll_next != null) {
+ node.ll_next.ll_prev = node.ll_prev;
+ } else if (_ll_tail == node) {
+ _ll_tail = node.ll_prev;
+ }
+
+ if (node.parent != null) {
+ if (node.parent.parent == _r_prime) {
+ _updated_degree ((Type1Node<G>) node.parent, true);
+ } else if (node.parent.parent != null) {
+ Type1Node<G> parent = (Type1Node<G>) node.parent;
+
+ // Increment parent's lost count
+ parent.lost++;
+
+ // And add it to LL if needed
+ if (parent.lost > 1) {
+ if (_ll_tail != null) {
+ parent.ll_prev = _ll_tail;
+ _ll_tail.ll_next = parent;
+ } else {
+ _ll_head = parent;
+ }
+ _ll_tail = parent;
+ }
+ }
+ }
+ }
+
+ // Check whether removed node is P
+ if (node == _p) {
+ _p = _r;
+ }
+
+ // Maintain brothers list
+ node.remove ();
+
+ // Maintain iteration
+ if (with_iteration) {
+ if (node.iter_prev != null) {
+ node.iter_prev.iter_next = node.iter_next;
+ } else if (_iter_head == node) {
+ _iter_head = node.iter_next;
+ }
+ if (node.iter_next != null) {
+ node.iter_next.iter_prev = node.iter_prev;
+ } else if (_iter_tail == node) {
+ _iter_tail = node.iter_prev;
+ }
+ }
+ #if DEBUG
+ _dump ("End _remove_type1_node: %p(%s)".printf (node, (string) node.data));
+ #endif
+ }
+
+ private void _updated_degree (Type1Node<G> node, bool child_removed) {
+ int degree = node.degree ();
+
+ // Ensure proper sizes of A and B
+ if (degree >= _a.length) {
+ _a.resize (degree + 1);
+ _b.resize (degree + 1);
+ }
+
+ // Maintain A and B
+ if (child_removed && _a[degree - 1] == null) {
+ _a[degree - 1] = node;
+ _b[degree - 1] = ! _b[degree - 1];
+ }
+
+ _b[degree] = ! _b[degree];
+ if (_a[degree] == node) {
+ Type1Node<G> next = node.brothers_next;
+ if (next != null && next.degree () == degree) {
+ _a[degree] = next;
+ } else {
+ _a[degree] = null;
+
+ int i = _a.length - 1;
+ while (i >= 0 && _a[i] == null) {
+ i--;
+ }
+ _a.resize (i + 1);
+ _b.resize (i + 1);
+ }
+ }
+
+ // Maintain LP
+ if (node.pair != null) {
+ NodePair<G> pair = node.pair;
+ Type1Node<G> other = (pair.node1 == node ? pair.node2 : pair.node1);
+ node.pair = null;
+ other.pair = null;
+ if (pair.lp_prev != null) {
+ pair.lp_prev.lp_next = pair.lp_next;
+ } else {
+ _lp_head = pair.lp_next;
+ }
+ if (pair.lp_next != null) {
+ pair.lp_next.lp_prev = pair.lp_prev;
+ } else {
+ _lp_tail = pair.lp_prev;
+ }
+ }
+ }
+
+ private void _remove_type2_node (Type2Node<G> node, bool with_iteration) {
+ #if DEBUG
+ _dump ("Start _remove_type2_node: %p(%s)".printf (node, (string) node.data));
+ #endif
+ ((Type1Node<G>) node.parent).type2_child = null;
+ node.parent = null;
+
+ // For now we can't have type2 node other than R' (left for reference)
+ #if false
+ // Maintain LM
+ if (node != _r_prime) {
+ if (node.lm_prev != null) {
+ node.lm_prev.lm_next = node.lm_next;
+ } else if (_lm_head == node) {
+ _lm_head = node.lm_next;
+ }
+ if (node.lm_next != null) {
+ node.lm_next.lm_prev = node.lm_prev;
+ } else if (_lm_tail == node) {
+ _lm_tail = node.lm_prev;
+ }
+ node.lm_next = null;
+ node.lm_prev = null;
+ }
+ #endif
+
+ // Maintain iteration
+ if (with_iteration) {
+ if (node.iter_prev != null) {
+ node.iter_prev.iter_next = node.iter_next;
+ } else if (_iter_head == node) {
+ _iter_head = node.iter_next;
+ }
+ if (node.iter_next != null) {
+ node.iter_next.iter_prev = node.iter_prev;
+ } else if (_iter_tail == node) {
+ _iter_tail = node.iter_prev;
+ }
+ }
+ #if DEBUG
+ _dump ("End _remove_type2_node: %p(%s)".printf (node, (string) node.data));
+ #endif
+ }
+
+ #if DEBUG
+ public void _dump (string message) {
+ stdout.printf (">>>> %s\n", message);
+
+ stdout.printf ("A.length = %d:", _a.length);
+ foreach (Node<G>? node in _a) {
+ stdout.printf (" %p(%s);", node, node != null ? (string) node.data : null);
+ }
+ stdout.printf ("\n");
+
+ stdout.printf ("B.length = %d:", _b.length);
+ foreach (bool even in _b) {
+ stdout.printf (" %s;", even.to_string ());
+ }
+ stdout.printf ("\n");
+
+ stdout.printf ("LP:");
+ unowned NodePair<G>? pair = _lp_head;
+ while (pair != null) {
+ stdout.printf (" (%p(%s),%p(%s));", pair.node1, (string) pair.node1.data, pair.node2,
(string) pair.node2.data);
+ pair = pair.lp_next;
+ }
+ stdout.printf ("\n");
+
+ stdout.printf ("LL:");
+ unowned Type1Node<G>? node = _ll_head;
+ while (node != null) {
+ stdout.printf (" %p(%s);", node, (string) node.data);
+ node = node.ll_next;
+ }
+ stdout.printf ("\n");
+
+ stdout.printf ("ITER:");
+ unowned Node<G>? inode_prev = null;
+ unowned Node<G>? inode = _iter_head;
+ while (inode != null) {
+ stdout.printf (" %p(%s);", inode, (string) inode.data);
+ assert (inode.iter_prev == inode_prev);
+ inode_prev = inode;
+ inode = inode.iter_next;
+ }
+ stdout.printf ("\n");
+
+ stdout.printf ("%s\n", _r != null ? _r.to_string () : null);
+
+ stdout.printf ("\n");
+ }
+ #endif
+
+ private abstract class Node<G> {
+ public G data;
+ public weak Node<G>? parent = null;
+
+ public int type1_children_count;
+ public Type1Node<G>? type1_children_head = null;
+ public Type1Node<G>? type1_children_tail = null;
+
+ public unowned Node<G>? iter_prev;
+ public unowned Node<G>? iter_next = null;
+
+ public bool pending_drop;
+
+ protected Node (G data, ref unowned Node<G>? head, ref unowned Node<G>? tail) {
+ this.data = data;
+ iter_prev = tail;
+ tail = this;
+ if (iter_prev != null) {
+ iter_prev.iter_next = this;
+ }
+ if (head == null) {
+ head = this;
+ }
+ }
+
+ public inline int degree () {
+ return type1_children_count;
+ }
+
+ #if DEBUG
+ public string children_to_string (int level = 0) {
+ StringBuilder builder = new StringBuilder ();
+ bool first = true;
+ Type1Node<G> child = type1_children_head;
+ while (child != null) {
+ if (!first) {
+ builder.append (",\n");
+ }
+ first = false;
+ builder.append (child.to_string (level));
+ child = child.brothers_next;
+ }
+ return builder.str;
+ }
+
+ public abstract string to_string (int level = 0);
+ #endif
+ }
+
+ private class Type1Node<G> : Node<G> {
+ public uint lost;
+ public weak Type1Node<G>? brothers_prev = null;
+ public Type1Node<G>? brothers_next = null;
+ public Type2Node<G>? type2_child = null;
+ public weak Type1Node<G>? ll_prev = null;
+ public Type1Node<G>? ll_next = null;
+ public weak NodePair<G>? pair = null;
+
+ public Type1Node (G data, ref unowned Node<G>? head, ref unowned Node<G>? tail) {
+ base (data, ref head, ref tail);
+ }
+
+ public inline void add (Type1Node<G> node) {
+ node.parent = this;
+ if (type1_children_head == null) {
+ type1_children_head = node;
+ } else {
+ node.brothers_prev = type1_children_tail;
+ }
+ if (type1_children_tail != null) {
+ type1_children_tail.brothers_next = node;
+ }
+ type1_children_tail = node;
+ type1_children_count++;
+ }
+
+ public inline void remove () {
+ if (brothers_prev == null) {
+ parent.type1_children_head = brothers_next;
+ } else {
+ brothers_prev.brothers_next = brothers_next;
+ }
+ if (brothers_next == null) {
+ parent.type1_children_tail = brothers_prev;
+ } else {
+ brothers_next.brothers_prev = brothers_prev;
+ }
+ parent.type1_children_count--;
+ parent = null;
+ brothers_prev = null;
+ brothers_next = null;
+ }
+
+ #if DEBUG
+ public override string to_string (int level = 0) {
+ StringBuilder builder = new StringBuilder ();
+ builder.append (string.nfill (level, '\t'));
+ builder.append ("(");
+ builder.append_printf("%p(%s)/%u", this, (string)data, lost);
+ if (type1_children_head != null || type2_child != null) {
+ builder.append (":\n");
+ }
+ if (type1_children_head != null) {
+ builder.append (children_to_string (level + 1));
+ }
+ if (type1_children_head != null && type2_child != null) {
+ builder.append (",\n");
+ }
+ if (type2_child != null) {
+ builder.append (type2_child.to_string (level + 1));
+ }
+ if (type1_children_head != null || type2_child != null) {
+ builder.append ("\n");
+ builder.append (string.nfill (level, '\t'));
+ }
+ builder.append (")");
+ return builder.str;
+ }
+ #endif
+ }
+
+ private class Type2Node<G> : Node<G> {
+ // For now we can't have type2 node other than R' (left for reference)
+ #if false
+ public weak Type2Node<G>? lm_prev = null;
+ public Type2Node<G>? lm_next = null;
+ #endif
+
+ public Type2Node (G data, ref unowned Node<G>? head, ref unowned Node<G>? tail) {
+ base (data, ref head, ref tail);
+ }
+
+ #if DEBUG
+ public override string to_string (int level = 0) {
+ StringBuilder builder = new StringBuilder ();
+ builder.append (string.nfill (level, '\t'));
+ builder.append_printf ("[%p(%s)", this, (string)data);
+ if (type1_children_head != null) {
+ builder.append (":\n");
+ builder.append (children_to_string (level + 1));
+ builder.append ("\n");
+ builder.append (string.nfill (level, '\t'));
+ }
+ builder.append ("]");
+ return builder.str;
+ }
+ #endif
+ }
+
+ private class DummyNode<G> : Node<G> {
+ public DummyNode (ref unowned Node<G>? prev_next, ref unowned Node<G>? next_prev, Node<G>?
iter_prev, Node<G>? iter_next) {
+ #if DEBUG
+ base ("<<dummy>>", ref prev_next, ref next_prev);
+ #else
+ base (null, ref prev_next, ref next_prev);
+ #endif
+ this.iter_prev = iter_prev;
+ this.iter_next = iter_next;
+ prev_next = next_prev = this;
+ }
+
+ #if DEBUG
+ public override string to_string (int level = 0) {
+ StringBuilder builder = new StringBuilder ();
+ builder.append (string.nfill (level, '\t'));
+ builder.append ("%p<<dummy>>".printf(this));
+ return builder.str;
+ }
+ #endif
+ }
+
+ private class NodePair<G> {
+ public weak NodePair<G>? lp_prev = null;
+ public NodePair<G>? lp_next = null;
+ public Type1Node<G> node1 = null;
+ public Type1Node<G> node2 = null;
+
+ public NodePair (Type1Node<G> node1, Type1Node<G> node2) {
+ this.node1 = node1;
+ this.node2 = node2;
+ }
+ }
+
+ private class Iterator<G> : Object, Traversable<G>, Vala.Iterator<G> {
+ private PriorityQueue<G> queue;
+ private unowned Node<G>? position;
+ private unowned Node<G>? previous;
+ private int stamp;
+
+ public Iterator (PriorityQueue<G> queue) {
+ this.queue = queue;
+ this.position = null;
+ this.previous = null;
+ this.stamp = queue._stamp;
+ }
+
+ public bool next () {
+ unowned Node<G>? next = _get_next_node ();
+ if (next != null) {
+ previous = position;
+ position = next;
+ }
+ return next != null;
+ }
+
+ public bool has_next () {
+ return _get_next_node () != null;
+ }
+
+ private inline unowned Node<G>? _get_next_node () {
+ if (position != null) {
+ return position.iter_next;
+ } else {
+ return (previous != null) ? previous.iter_next : queue._iter_head;
+ }
+ }
+
+ public new G get () {
+ assert (stamp == queue._stamp);
+ assert (position != null);
+ return position.data;
+ }
+
+ public void remove () {
+ assert (stamp == queue._stamp);
+ assert (position != null);
+ DummyNode<G> dn;
+ if (previous != null) {
+ dn = new DummyNode<G> (ref previous.iter_next, ref position.iter_prev,
previous, position);
+ } else {
+ dn = new DummyNode<G> (ref queue._iter_head, ref position.iter_prev, null,
position);
+ }
+ queue._delete (position);
+ position = null;
+ if (previous != null) {
+ previous.iter_next = dn.iter_next;
+ }
+ if (dn == queue._iter_head) {
+ queue._iter_head = dn.iter_next;
+ }
+ if (dn.iter_next != null) {
+ dn.iter_next.iter_prev = previous;
+ }
+ if (dn == queue._iter_tail) {
+ queue._iter_tail = previous;
+ }
+ stamp++;
+ assert (stamp == queue._stamp);
+ }
+
+ public bool read_only { get { return false; } }
+
+ public bool valid { get { return position != null; } }
+
+ public bool foreach (ForallFunc<G> f) {
+ if (position == null) {
+ position = (previous != null) ? previous.iter_next : queue._iter_head;
+ }
+ if (position == null) {
+ return true;
+ }
+ if (!f (position.data)) {
+ return false;
+ }
+ while (position.iter_next != null) {
+ previous = position;
+ position = position.iter_next;
+ if (!f (position.data)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+}
diff --git a/gee/queue.vala b/gee/queue.vala
new file mode 100644
index 0000000..df678d1
--- /dev/null
+++ b/gee/queue.vala
@@ -0,0 +1,115 @@
+/* queue.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * A collection designed for holding elements prior to processing.
+ *
+ * Although all Queue implementations do not limit the amount of elements they
+ * can contain, this interface supports for capacity-bounded queues. When
+ * capacity is not bound, then the {@link capacity} and
+ * {@link remaining_capacity} both return {@link UNBOUNDED_CAPACITY}.
+ *
+ * This interface defines methods that will never fail whatever the state of
+ * the queue is. For capacity-bounded queues, those methods will either return
+ * ``false`` or ``null`` to specify that the insert or retrieval did not occur
+ * because the queue was full or empty.
+ *
+ * Queue implementations are not limited to First-In-First-Out behavior and can
+ * propose different ordering of their elements. Each Queue implementation have
+ * to specify how it orders its elements.
+ *
+ * Queue implementations do not allow insertion of ``null`` elements, although
+ * some implementations, such as {@link LinkedList}, do not prohibit insertion
+ * of ``null``. Even in the implementations that permit it, ``null`` should not be
+ * inserted into a Queue, as ``null`` is also used as a special return value by
+ * the poll method to indicate that the queue contains no elements.
+ */
+[GenericAccessors]
+public interface Vala.Queue<G> : Collection<G> {
+
+ /**
+ * The unbounded capacity value.
+ */
+ public const int UNBOUNDED_CAPACITY = -1;
+
+ /**
+ * The capacity of this queue (or ``null`` if capacity is not bound).
+ */
+ public abstract int capacity { get; }
+
+ /**
+ * The remaining capacity of this queue (or ``null`` if capacity is not
+ * bound).
+ */
+ public abstract int remaining_capacity { get; }
+
+ /**
+ * Specifies whether this queue is full.
+ */
+ public abstract bool is_full { get; }
+
+ /**
+ * Offers the specified element to this queue.
+ *
+ * @param element the element to offer to the queue
+ *
+ * @return ``true`` if the element was added to the queue
+ */
+ public virtual bool offer (G element) {
+ return add (element);
+ }
+
+ /**
+ * Peeks (retrieves, but not remove) an element from this queue.
+ *
+ * @return the element peeked from the queue (or ``null`` if none was
+ * available)
+ */
+ public abstract G? peek ();
+
+ /**
+ * Polls (retrieves and remove) an element from this queue.
+ *
+ * @return the element polled from the queue (or ``null`` if none was
+ * available)
+ */
+ public abstract G? poll ();
+
+ /**
+ * Drains the specified amount of elements from this queue in the specified
+ * recipient collection.
+ *
+ * @param recipient the recipient collection to drain the elements to
+ * @param amount the amount of elements to drain
+ *
+ * @return the amount of elements that were actually drained
+ */
+ public virtual int drain (Collection<G> recipient, int amount = -1) {
+ G? item = null;
+ int drained = 0;
+ while((amount == -1 || --amount >= 0) && (item = poll ()) != null) {
+ recipient.add (item);
+ drained++;
+ }
+ return drained;
+ }
+}
diff --git a/gee/readonlybidirlist.vala b/gee/readonlybidirlist.vala
new file mode 100644
index 0000000..3287950
--- /dev/null
+++ b/gee/readonlybidirlist.vala
@@ -0,0 +1,73 @@
+/* readonlybidirlist.vala
+ *
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+internal class Vala.ReadOnlyBidirList<G> : Vala.ReadOnlyList<G>, BidirList<G> {
+
+ /**
+ * Constructs a read-only list that mirrors the content of the specified
+ * list.
+ *
+ * @param list the list to decorate.
+ */
+ public ReadOnlyBidirList (BidirList<G> list) {
+ base (list);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public BidirListIterator<G> bidir_list_iterator () {
+ return new Iterator<G> (((Vala.BidirList<G>) _collection).bidir_list_iterator ());
+ }
+
+ /**
+ * The read-only view of this list.
+ */
+ public virtual new BidirList<G> read_only_view { owned get { return this; } }
+
+ private class Iterator<G> : ReadOnlyList.Iterator<G>, BidirIterator<G>, BidirListIterator<G> {
+ public Iterator (ListIterator<G> iterator) {
+ base (iterator);
+ }
+
+ public bool previous () {
+ return ((BidirIterator<G>) _iter).previous ();
+ }
+
+ public bool has_previous () {
+ return ((BidirIterator<G>) _iter).has_previous ();
+ }
+
+ public bool first () {
+ return ((BidirIterator<G>) _iter).first ();
+ }
+
+ public bool last () {
+ return ((BidirIterator<G>) _iter).last ();
+ }
+
+ public void insert (G item) {
+ assert_not_reached ();
+ }
+ }
+}
+
diff --git a/gee/readonlybidirsortedmap.vala b/gee/readonlybidirsortedmap.vala
new file mode 100644
index 0000000..a50c036
--- /dev/null
+++ b/gee/readonlybidirsortedmap.vala
@@ -0,0 +1,80 @@
+/* readonlybidirsortedmap.vala
+ *
+ * Copyright (C) 2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Read-only view for {@link BidirSortedMap} collections.
+ *
+ * This class decorates any class which implements the {@link BidirSortedMap}
+ * interface by making it read only. Any method which normally modify data will
+ * throw an error.
+ *
+ * @see BidirSortedMap
+ */
+internal class Vala.ReadOnlyBidirSortedMap<K,V> : ReadOnlySortedMap<K,V>, BidirSortedMap<K,V> {
+ /**
+ * Constructs a read-only map that mirrors the content of the specified map.
+ *
+ * @param set the set to decorate.
+ */
+ public ReadOnlyBidirSortedMap (BidirSortedMap<K,V> map) {
+ base (map);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Vala.BidirMapIterator<K,V> bidir_map_iterator () {
+ return new BidirMapIterator<K,V> ((_map as BidirSortedMap<K,V>).bidir_map_iterator ());
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public new BidirSortedMap<K,V> read_only_view {
+ owned get {
+ return this;
+ }
+ }
+
+ protected class BidirMapIterator<K,V> : Vala.ReadOnlyMap.MapIterator<K,V>, Vala.BidirMapIterator<K,V>
{
+ public BidirMapIterator (Vala.BidirMapIterator<K,V> iterator) {
+ base (iterator);
+ }
+
+ public bool first () {
+ return (_iter as Vala.BidirMapIterator<K,V>).first ();
+ }
+
+ public bool previous () {
+ return (_iter as Vala.BidirMapIterator<K,V>).previous ();
+ }
+
+ public bool has_previous () {
+ return (_iter as Vala.BidirMapIterator<K,V>).has_previous ();
+ }
+
+ public bool last () {
+ return (_iter as Vala.BidirMapIterator<K,V>).last ();
+ }
+ }
+}
+
diff --git a/gee/readonlybidirsortedset.vala b/gee/readonlybidirsortedset.vala
new file mode 100644
index 0000000..f5b4ad7
--- /dev/null
+++ b/gee/readonlybidirsortedset.vala
@@ -0,0 +1,71 @@
+/* readonlybidirsortedset.vala
+ *
+ * Copyright (C) 2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Read-only view for {@link BidirSortedSet} collections.
+ *
+ * This class decorates any class which implements the {@link BidirSortedSet}
+ * interface by making it read only. Any method which normally modify data will
+ * throw an error.
+ *
+ * @see BidirSortedSet
+ */
+internal class Vala.ReadOnlyBidirSortedSet<G> : ReadOnlySortedSet<G>, BidirSortedSet<G> {
+ /**
+ * Constructs a read-only set that mirrors the content of the specified set.
+ *
+ * @param set the set to decorate.
+ */
+ public ReadOnlyBidirSortedSet (BidirSortedSet<G> set) {
+ base (set);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Vala.BidirIterator<G> bidir_iterator () {
+ return new BidirIterator<G> ((_collection as BidirSortedSet<G>).bidir_iterator ());
+ }
+
+ protected class BidirIterator<G> : Vala.ReadOnlyCollection.Iterator<G>, Vala.BidirIterator<G> {
+ public BidirIterator (Vala.BidirIterator<G> iterator) {
+ base (iterator);
+ }
+
+ public bool first () {
+ return (_iter as Vala.BidirIterator<G>).first ();
+ }
+
+ public bool previous () {
+ return (_iter as Vala.BidirIterator<G>).previous ();
+ }
+
+ public bool has_previous () {
+ return (_iter as Vala.BidirIterator<G>).has_previous ();
+ }
+
+ public bool last () {
+ return (_iter as Vala.BidirIterator<G>).last ();
+ }
+ }
+}
+
diff --git a/gee/readonlycollection.vala b/gee/readonlycollection.vala
new file mode 100644
index 0000000..f810f20
--- /dev/null
+++ b/gee/readonlycollection.vala
@@ -0,0 +1,235 @@
+/* readonlycollection.vala
+ *
+ * Copyright (C) 2007-2008 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j bitron ch>
+ */
+
+using GLib;
+
+/**
+ * Read-only view for {@link Collection} collections.
+ *
+ * This class decorates any class which implements the {@link Collection}
+ * interface by making it read only. Any method which normally modify data will
+ * throw an error.
+ *
+ * @see Collection
+ */
+internal class Vala.ReadOnlyCollection<G> : Object, Traversable<G>, Iterable<G>, Collection<G> {
+
+ /**
+ * {@inheritDoc}
+ */
+ public int size {
+ get { return _collection.size; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool is_empty {
+ get { return _collection.is_empty; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool read_only {
+ get { return true; }
+ }
+
+ protected Collection<G> _collection;
+
+ /**
+ * Constructs a read-only collection that mirrors the content of the
+ * specified collection.
+ *
+ * @param collection the collection to decorate.
+ */
+ public ReadOnlyCollection (Collection<G> collection) {
+ this._collection = collection;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool foreach (ForallFunc<G> f) {
+ return _collection.foreach (f);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Vala.Iterator<A> stream<A> (owned StreamFunc<A> f) {
+ return _collection.stream<A> ((owned)f);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Vala.Iterator<G> filter (owned Predicate<G> f) {
+ return _collection.filter ((owned)f);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Vala.Iterator<G> chop (int offset, int length = -1) {
+ return _collection.chop (offset, length);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Type element_type {
+ get { return typeof (G); }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Vala.Iterator<G> iterator () {
+ return new Iterator<G> (_collection.iterator ());
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool contains (G item) {
+ return _collection.contains (item);
+ }
+
+ /**
+ * Unimplemented method (read only collection).
+ */
+ public bool add (G item) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only collection).
+ */
+ public bool remove (G item) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only collection).
+ */
+ public void clear () {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only collection).
+ */
+ public bool add_all (Collection<G> collection) {
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool contains_all (Collection<G> collection) {
+ return _collection.contains_all (collection);
+ }
+
+ /**
+ * Unimplemented method (read only collection).
+ */
+ public bool remove_all (Collection<G> collection) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only collection).
+ */
+ public bool retain_all (Collection<G> collection) {
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G[] to_array () {
+ return _collection.to_array ();
+ }
+
+ protected class Iterator<G> : Object, Traversable<G>, Vala.Iterator<G> {
+ protected Vala.Iterator<G> _iter;
+
+ public Iterator (Vala.Iterator<G> iterator) {
+ _iter = iterator;
+ }
+
+ public bool next () {
+ return _iter.next ();
+ }
+
+ public bool has_next () {
+ return _iter.has_next ();
+ }
+
+ public new G get () {
+ return _iter.get ();
+ }
+
+ public void remove () {
+ assert_not_reached ();
+ }
+
+ public bool valid {
+ get {
+ return _iter.valid;
+ }
+ }
+
+ public bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public Type element_type {
+ get { return typeof (G); }
+ }
+
+ public bool foreach (ForallFunc<G> f) {
+ return _iter.foreach (f);
+ }
+
+ public Vala.Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
+ return _iter.stream<A> ((owned)f);
+ }
+
+ public Vala.Iterator<G> filter (owned Predicate<G> f) {
+ return _iter.filter ((owned)f);
+ }
+
+ public Vala.Iterator<G> chop (int offset, int length = -1) {
+ return _iter.chop ( offset, length);
+ }
+ }
+
+ public virtual Collection<G> read_only_view {
+ owned get { return this; }
+ }
+
+}
+
diff --git a/gee/readonlylist.vala b/gee/readonlylist.vala
new file mode 100644
index 0000000..de44c65
--- /dev/null
+++ b/gee/readonlylist.vala
@@ -0,0 +1,149 @@
+/* readonlylist.vala
+ *
+ * Copyright (C) 2007-2008 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j bitron ch>
+ */
+
+using GLib;
+
+/**
+ * Read-only view for {@link List} collections.
+ *
+ * This class decorates any class which implements the {@link List}
+ * interface by making it read only. Any method which normally modify data will
+ * throw an error.
+ *
+ * @see List
+ */
+internal class Vala.ReadOnlyList<G> : Vala.ReadOnlyCollection<G>, List<G> {
+
+ /**
+ * Constructs a read-only list that mirrors the content of the specified
+ * list.
+ *
+ * @param list the list to decorate.
+ */
+ public ReadOnlyList (List<G> list) {
+ base (list);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public ListIterator<G> list_iterator () {
+ return new Iterator<G> (((Vala.List<G>) _collection).list_iterator ());
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int index_of (G item) {
+ return ((Vala.List<G>) _collection).index_of (item);
+ }
+
+ /**
+ * Unimplemented method (read only list).
+ */
+ public void insert (int index, G item) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only list).
+ */
+ public G remove_at (int index) {
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public new G? get (int index) {
+ return ((Vala.List<G>) _collection).get (index);
+ }
+
+ /**
+ * Unimplemented method (read only list).
+ */
+ public new void set (int index, G o) {
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public List<G>? slice (int start, int stop) {
+ return ((Vala.List<G>) _collection).slice (start, stop);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? first () {
+ return ((Vala.List<G>) _collection).first ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? last () {
+ return ((Vala.List<G>) _collection).last ();
+ }
+
+ /**
+ * Unimplemented method (read only list).
+ */
+ public void insert_all (int index, Collection<G> collection) {
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void sort (owned CompareDataFunc<G>? compare = null) {
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public virtual new List<G> read_only_view {
+ owned get { return this; }
+ }
+
+
+ protected class Iterator<G> : ReadOnlyCollection.Iterator<G>, ListIterator<G> {
+ public Iterator (ListIterator<G> iterator) {
+ base (iterator);
+ }
+
+ public new void set (G item) {
+ assert_not_reached ();
+ }
+
+ public void add (G item) {
+ assert_not_reached ();
+ }
+
+ public int index () {
+ return ((ListIterator<G>) _iter).index ();
+ }
+ }
+}
+
diff --git a/gee/readonlymap.vala b/gee/readonlymap.vala
new file mode 100644
index 0000000..c14ebbe
--- /dev/null
+++ b/gee/readonlymap.vala
@@ -0,0 +1,297 @@
+/* readonlymap.vala
+ *
+ * Copyright (C) 2007-2008 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j bitron ch>
+ */
+
+using GLib;
+
+/**
+ * Read-only view for {@link Map} collections.
+ *
+ * This class decorates any class which implements the {@link Map} interface
+ * by making it read only. Any method which normally modify data will throw an
+ * error.
+ *
+ * @see Map
+ */
+internal class Vala.ReadOnlyMap<K,V> : Object, Traversable<Map.Entry<K,V>>, Iterable<Map.Entry<K,V>>,
Map<K,V> {
+
+ /**
+ * {@inheritDoc}
+ */
+ public int size {
+ get { return _map.size; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool is_empty {
+ get { return _map.is_empty; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool read_only {
+ get { return true; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Set<K> keys {
+ owned get {
+ return _map.keys;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Collection<V> values {
+ owned get {
+ return _map.values;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Set<Map.Entry<K,V>> entries {
+ owned get {
+ return _map.entries;
+ }
+ }
+
+ protected Map<K,V> _map;
+
+ /**
+ * Constructs a read-only map that mirrors the content of the specified map.
+ *
+ * @param map the map to decorate.
+ */
+ public ReadOnlyMap (Map<K,V> map) {
+ this._map = map;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool has_key (K key) {
+ return _map.has_key (key);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool contains (K key) {
+ return _map.has_key (key);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool has (K key, V value) {
+ return _map.has (key, value);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public new V? get (K key) {
+ return _map.get (key);
+ }
+
+ /**
+ * Unimplemented method (read only map).
+ */
+ public new void set (K key, V value) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only map).
+ */
+ public bool unset (K key, out V? value = null) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only map).
+ */
+ public bool remove (K key, out V? value = null) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only map).
+ */
+ public void clear () {
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Vala.MapIterator<K,V> map_iterator () {
+ return new MapIterator<K,V> (_map.map_iterator ());
+ }
+
+ /**
+ * Unimplemented method (read only map).
+ */
+ public void set_all (Map<K,V> map) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only map).
+ */
+ public bool unset_all (Map<K,V> map) {
+ assert_not_reached ();
+ }
+
+ /**
+ * Unimplemented method (read only map).
+ */
+ public bool remove_all (Map<K,V> map) {
+ assert_not_reached ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool has_all (Map<K,V> map) {
+ return _map.has_all (map);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool contains_all (Map<K,V> map) {
+ return _map.has_all (map);
+ }
+
+ public virtual Map<K,V> read_only_view {
+ owned get { return this; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Type key_type {
+ get { return typeof (K); }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Type value_type {
+ get { return typeof (V); }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Type element_type {
+ get { return typeof (Map.Entry); }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Iterator<Map.Entry<K,V>> iterator () {
+ return entries.iterator ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public bool foreach (ForallFunc<Map.Entry<K, V>> f) {
+ return _map.foreach (f);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Iterator<A> stream<A> (owned StreamFunc<Map.Entry<K, V>, A> f) {
+ return _map.stream<A> ((owned) f);
+ }
+
+ public Iterator<Map.Entry<K, V>> filter (owned Predicate<Map.Entry<K, V>> f) {
+ return _map.filter ((owned)f);
+ }
+
+ public Iterator<Map.Entry<K, V>> chop (int offset, int length = -1) {
+ return _map.chop (offset, length);
+ }
+
+ protected class MapIterator<K,V> : Object, Vala.MapIterator<K,V> {
+ protected Vala.MapIterator<K,V> _iter;
+
+ public MapIterator (Vala.MapIterator<K,V> iterator) {
+ _iter = iterator;
+ }
+
+ public bool next () {
+ return _iter.next ();
+ }
+
+ public bool has_next () {
+ return _iter.has_next ();
+ }
+
+ public K get_key () {
+ return _iter.get_key ();
+ }
+
+ public V get_value () {
+ return _iter.get_value ();
+ }
+
+ public void set_value (V value) {
+ assert_not_reached ();
+ }
+
+ public void unset () {
+ assert_not_reached ();
+ }
+
+ public bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public bool mutable {
+ get {
+ return false;
+ }
+ }
+
+ public bool valid {
+ get {
+ return _iter.valid;
+ }
+ }
+ }
+}
+
diff --git a/gee/readonlyset.vala b/gee/readonlyset.vala
new file mode 100644
index 0000000..f8b1f9d
--- /dev/null
+++ b/gee/readonlyset.vala
@@ -0,0 +1,50 @@
+/* readonlyset.vala
+ *
+ * Copyright (C) 2007-2008 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j bitron ch>
+ */
+
+using GLib;
+
+/**
+ * Read-only view for {@link Set} collections.
+ *
+ * This class decorates any class which implements the {@link Set} interface
+ * by making it read only. Any method which normally modify data will throw an
+ * error.
+ *
+ * @see Set
+ */
+internal class Vala.ReadOnlySet<G> : Vala.ReadOnlyCollection<G>, Set<G> {
+
+ /**
+ * Constructs a read-only set that mirrors the content of the specified set.
+ *
+ * @param set the set to decorate.
+ */
+ public ReadOnlySet (Set<G> set) {
+ base (set);
+ }
+
+ public virtual new Set<G> read_only_view {
+ owned get { return this; }
+ }
+
+}
+
diff --git a/gee/readonlysortedmap.vala b/gee/readonlysortedmap.vala
new file mode 100644
index 0000000..3b87455
--- /dev/null
+++ b/gee/readonlysortedmap.vala
@@ -0,0 +1,90 @@
+/* readonlysortedmap.vala
+ *
+ * Copyright (C) 2009-2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Read-only view for {@link SortedMap} collections.
+ *
+ * This class decorates any class which implements the {@link SortedMap} interface
+ * by making it read only. Any method which normally modify data will throw an
+ * error.
+ *
+ * @see SortedMap
+ */
+internal class Vala.ReadOnlySortedMap<K,V> : ReadOnlyMap<K,V>, SortedMap<K,V> {
+ /**
+ * Constructs a read-only map that mirrors the content of the specified map.
+ *
+ * @param map the map to decorate.
+ */
+ public ReadOnlySortedMap (Map<K,V> map) {
+ base (map);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SortedMap<K,V> head_map (K before) {
+ return (_map as SortedMap<K,V>).head_map (before).read_only_view;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SortedMap<K,V> tail_map (K after) {
+ return (_map as SortedMap<K,V>).tail_map (after).read_only_view;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SortedMap<K,V> sub_map (K from, K to) {
+ return (_map as SortedMap<K,V>).sub_map (from, to).read_only_view;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SortedSet<K> ascending_keys {
+ owned get {
+ return (_map as SortedMap<K,V>).ascending_keys.read_only_view;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SortedSet<Map.Entry<K,V>> ascending_entries {
+ owned get {
+ return (_map as SortedMap<K,V>).ascending_entries.read_only_view;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public new SortedMap<K, V> read_only_view {
+ owned get {
+ return this;
+ }
+ }
+}
+
diff --git a/gee/readonlysortedset.vala b/gee/readonlysortedset.vala
new file mode 100644
index 0000000..85cd776
--- /dev/null
+++ b/gee/readonlysortedset.vala
@@ -0,0 +1,123 @@
+/* readonlysortedset.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois, Maciej Piechotka
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Read-only view for {@link SortedSet} collections.
+ *
+ * This class decorates any class which implements the {@link SortedSet} interface
+ * by making it read only. Any method which normally modify data will throw an
+ * error.
+ *
+ * @see SortedSet
+ */
+internal class Vala.ReadOnlySortedSet<G> : ReadOnlySet<G>, SortedSet<G> {
+ /**
+ * Constructs a read-only set that mirrors the content of the specified set.
+ *
+ * @param set the set to decorate.
+ */
+ public ReadOnlySortedSet (SortedSet<G> set) {
+ base (set);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G first () {
+ return (_collection as SortedSet<G>).first ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G last () {
+ return (_collection as SortedSet<G>).last ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Vala.Iterator<G>? iterator_at (G element) {
+ var iter = (_collection as SortedSet<G>).iterator_at (element);
+ return (iter != null) ? new Iterator<G> (iter) : null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? lower (G element) {
+ return (_collection as SortedSet<G>).lower (element);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? higher (G element) {
+ return (_collection as SortedSet<G>).higher (element);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? floor (G element) {
+ return (_collection as SortedSet<G>).floor (element);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public G? ceil (G element) {
+ return (_collection as SortedSet<G>).ceil (element);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SortedSet<G> head_set (G before) {
+ return (_collection as SortedSet<G>).head_set (before).read_only_view;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SortedSet<G> tail_set (G after) {
+ return(_collection as SortedSet<G>).tail_set (after).read_only_view;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SortedSet<G> sub_set (G from, G to) {
+ return (_collection as SortedSet<G>).sub_set (from, to).read_only_view;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public new SortedSet<G> read_only_view {
+ owned get {
+ return this;
+ }
+ }
+}
+
diff --git a/gee/set.vala b/gee/set.vala
index 6449023..ab946c2 100644
--- a/gee/set.vala
+++ b/gee/set.vala
@@ -21,8 +21,23 @@
*/
/**
- * A set is a collection without duplicates.
+ * A collection without duplicate elements.
*/
-public abstract class Vala.Set<G> : Collection<G> {
+[GenericAccessors]
+public interface Vala.Set<G> : Collection<G> {
+
+ /**
+ * The read-only view of this set.
+ */
+ public abstract new Set<G> read_only_view { owned get; }
+
+ /**
+ * Returns an immutable empty set.
+ *
+ * @return an immutable empty set
+ */
+ public static Set<G> empty<G> () {
+ return new HashSet<G> ().read_only_view;
+ }
}
diff --git a/gee/sortedmap.vala b/gee/sortedmap.vala
new file mode 100644
index 0000000..8b23201
--- /dev/null
+++ b/gee/sortedmap.vala
@@ -0,0 +1,66 @@
+/* sortedset.vala
+ *
+ * Copyright (C) 2009-2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+public interface Vala.SortedMap<K,V> : Vala.Map<K,V> {
+ /**
+ * Returns map containing pairs with key strictly lower the the argument.
+ */
+ public abstract SortedMap<K,V> head_map (K before);
+
+ /**
+ * Returns map containing pairs with key equal or larger then the argument.
+ */
+ public abstract SortedMap<K,V> tail_map (K after);
+
+ /**
+ * Returns right-open map (i.e. containing all pair which key is strictly
+ * lower then the second argument and equal or bigger then the first one).
+ *
+ * Null as one parameter means that it should include all from this side.
+ */
+ public abstract SortedMap<K,V> sub_map (K before, K after);
+
+ /**
+ * Returns the keys in ascending order.
+ */
+ public abstract SortedSet<K> ascending_keys { owned get; }
+
+ /**
+ * Returns the entries in ascending order.
+ */
+ public abstract SortedSet<Map.Entry<K,V>> ascending_entries { owned get; }
+
+ /**
+ * The read-only view this map.
+ */
+ public new abstract SortedMap<K,V> read_only_view { owned get; }
+
+ /**
+ * Returns an immutable empty map.
+ *
+ * @return an immutable empty map
+ */
+ public static Map<K,V> empty<K,V> () {
+ return new TreeMap<K,V> ().read_only_view;
+ }
+}
+
diff --git a/gee/sortedset.vala b/gee/sortedset.vala
new file mode 100644
index 0000000..66ea370
--- /dev/null
+++ b/gee/sortedset.vala
@@ -0,0 +1,137 @@
+/* sortedset.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois, Maciej Piechotka
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * A sorted set, which you can navigate over and get sub-sets of.
+ */
+[GenericAccessors]
+public interface Vala.SortedSet<G> : Vala.Set<G> {
+ /**
+ * Returns the first element of the sorted set. Set must not be empty.
+ *
+ * @return the first element in the sorted set
+ */
+ public abstract G first ();
+
+ /**
+ * Returns the last element of the sorted set. Set must not be empty.
+ *
+ * @return the last element in the sorted set
+ */
+ public abstract G last ();
+
+ /**
+ * Returns a {@link BidirIterator} initialy pointed at the specified
+ * element.
+ *
+ * @param element the element to point the iterator at
+ *
+ * @return a {@link BidirIterator} over this sorted set, or null if
+ * the specified element is not in this set
+ */
+ public abstract Iterator<G>? iterator_at (G element);
+
+ /**
+ * Returns the element which is strictly lower than the specified element.
+ *
+ * @param element the element which you want the lower element for
+ *
+ * @return the corresponding element
+ */
+ public abstract G? lower (G element);
+
+ /**
+ * Returns the element which is strictly higher than the specified element.
+ *
+ * @param element the element which you want the strictly higher element
+ * for
+ *
+ * @return the corresponding element
+ */
+ public abstract G? higher (G element);
+
+ /**
+ * Returns the element which is lower or equal then the specified element.
+ *
+ * @param element the element which you want the lower or equal element for
+ *
+ * @return the corresponding element
+ */
+ public abstract G? floor (G element);
+
+ /**
+ * Returns the element which is higher or equal then the specified element.
+ *
+ * @param element the element which you want the higher or equal element
+ * for
+ *
+ * @return the corresponding element
+ */
+ public abstract G? ceil (G element);
+
+ /**
+ * Returns the sub-set of this sorted set containing elements strictly
+ * lower than the specified element.
+ *
+ * @param before the lower inclusive bound for the sub-set
+ *
+ * @return the corresponding sub-set of this sorted set
+ */
+ public abstract SortedSet<G> head_set (G before);
+
+ /**
+ * Returns the sub-set of this sorted set containing elements equal or
+ * higher than the specified element.
+ *
+ * @param after the higher exclusive bound for the sub-set
+ *
+ * @return the corresponding sub-set of this sorted set
+ */
+ public abstract SortedSet<G> tail_set (G after);
+
+ /**
+ * Returns the right-open sub-set of this sorted set, thus containing
+ * elements equal or higher than the specified ``from`` element, and stricly
+ * lower than the specified ``to`` element.
+ *
+ * @param from the lower inclusive bound for the sub-set
+ * @param to the higher exclusive bound for the sub-set
+ *
+ * @return the corresponding sub-set of this sorted set
+ */
+ public abstract SortedSet<G> sub_set (G from, G to);
+
+ /**
+ * The read-only view of this set.
+ */
+ public abstract new SortedSet<G> read_only_view { owned get; }
+
+ /**
+ * Returns an immutable empty sorted set.
+ *
+ * @return an immutable empty sorted set
+ */
+ public static SortedSet<G> empty<G> () {
+ return new TreeSet<G> ().read_only_view;
+ }
+}
diff --git a/gee/timsort.vala b/gee/timsort.vala
new file mode 100644
index 0000000..5d1a862
--- /dev/null
+++ b/gee/timsort.vala
@@ -0,0 +1,713 @@
+/* timsort.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * A stable, adaptive, iterative mergesort that requires far fewer than n*lg(n)
+ * comparisons when running on partially sorted arrays, while offering
+ * performance comparable to a traditional mergesort when run on random arrays.
+ * Like all proper mergesorts, this sort is stable and runs O(n*log(n)) time
+ * (worst case). In the worst case, this sort requires temporary storage space
+ * for n/2 object references; in the best case, it requires only a small
+ * constant amount of space.
+ *
+ * This implementation was adapted from Tim Peters's list sort for Python,
+ * which is described in detail here:
+ * [[http://svn.python.org/projects/python/trunk/Objects/listsort.txt]]
+ *
+ * Tim's C code may be found here:
+ * [[http://svn.python.org/projects/python/trunk/Objects/listobject.c]]
+ *
+ * The underlying techniques are described in this paper (and may have even
+ * earlier origins):
+ *
+ * "Optimistic Sorting and Information Theoretic Complexity"
+ * Peter McIlroy
+ * SODA (Fourth Annual ACM-SIAM Symposium on Discrete Algorithms), pp
+ * 467-474, Austin, Texas, 25-27 January 1993.
+ */
+internal class Vala.TimSort<G> : Object {
+
+ public static void sort<G> (List<G> list, CompareDataFunc<G> compare) {
+ if (list is ArrayList) {
+ TimSort.sort_arraylist<G> ((ArrayList<G>) list, compare);
+ } else {
+ TimSort.sort_list<G> (list, compare);
+ }
+ }
+
+ private static void sort_list<G> (List<G> list, CompareDataFunc<G> compare) {
+ TimSort<G> helper = new TimSort<G> ();
+
+ helper.list_collection = list;
+ helper.array = list.to_array ();
+ helper.list = helper.array;
+ helper.index = 0;
+ helper.size = list.size;
+ helper.compare = compare;
+
+ helper.do_sort ();
+
+ // TODO Use a list iterator and use iter.set (item)
+ list.clear ();
+ foreach (G item in helper.array) {
+ list.add (item);
+ }
+ }
+
+ private static void sort_arraylist<G> (ArrayList<G> list, CompareDataFunc<G> compare) {
+ TimSort<G> helper = new TimSort<G> ();
+
+ helper.list_collection = list;
+ helper.list = list._items;
+ helper.index = 0;
+ helper.size = list._size;
+ helper.compare = compare;
+
+ helper.do_sort ();
+ }
+
+ private const int MINIMUM_GALLOP = 7;
+
+ private List<G> list_collection;
+ private G[] array;
+ private void** list;
+ private int index;
+ private int size;
+ private Slice<G>[] pending;
+ private int minimum_gallop;
+ private CompareDataFunc<G> compare;
+
+ private void do_sort () {
+ if (size < 2) {
+ return;
+ }
+
+ pending = new Slice<G>[0];
+ minimum_gallop = MINIMUM_GALLOP;
+
+ Slice<G> remaining = new Slice<G> (list, index, size);
+ int minimum_length = compute_minimum_run_length (remaining.length);
+
+ while (remaining.length > 0) {
+ // Get the next run
+ bool descending;
+ Slice<G> run = compute_longest_run (remaining, out descending);
+ #if DEBUG
+ message ("New run (%d, %d) %s", run.index, run.length,
+ descending ? "descending" : "ascending");
+ #endif
+ if (descending) {
+ run.reverse ();
+ }
+
+ // Extend it to minimum_length, if needed
+ if (run.length < minimum_length) {
+ int sorted_count = run.length;
+ run.length = int.min (minimum_length, remaining.length);
+ insertion_sort (run, sorted_count);
+ #if DEBUG
+ message ("Extended to (%d, %d) and sorted from index %d",
+ run.index, run.length, sorted_count);
+ #endif
+ }
+
+ // Move remaining after run
+ remaining.shorten_start (run.length);
+
+ // Add run to pending runs and try to merge
+ pending += (owned) run;
+ merge_collapse ();
+ }
+
+ assert (remaining.index == size);
+
+ merge_force_collapse ();
+
+ assert (pending.length == 1);
+ assert (pending[0].index == 0);
+ assert (pending[0].length == size);
+ }
+
+ private delegate bool LowerFunc (G left, G right);
+
+ private inline bool lower_than (G left, G right) {
+ return compare (left, right) < 0;
+ }
+
+ private inline bool lower_than_or_equal_to (G left, G right) {
+ return compare (left, right) <= 0;
+ }
+
+ private int compute_minimum_run_length (int length) {
+ int run_length = 0;
+ while (length >= 64) {
+ run_length |= length & 1;
+ length >>= 1;
+ }
+ return length + run_length;
+ }
+
+ private Slice<G> compute_longest_run (Slice<G> a, out bool descending) {
+ int run_length;
+ if (a.length <= 1) {
+ run_length = a.length;
+ descending = false;
+ } else {
+ run_length = 2;
+ if (lower_than (a.list[a.index + 1], a.list[a.index])) {
+ descending = true;
+ for (int i = a.index + 2; i < a.index + a.length; i++) {
+ if (lower_than (a.list[i], a.list[i-1])) {
+ run_length++;
+ } else {
+ break;
+ }
+ }
+ } else {
+ descending = false;
+ for (int i = a.index + 2; i < a.index + a.length; i++) {
+ if (lower_than (a.list[i], a.list[i-1])) {
+ break;
+ } else {
+ run_length++;
+ }
+ }
+ }
+ }
+ return new Slice<G> (a.list, a.index, run_length);
+ }
+
+ private void insertion_sort (Slice<G> a, int offset) {
+ #if DEBUG
+ message ("Sorting (%d, %d) at %d", a.index, a.length, offset);
+ #endif
+ for (int start = a.index + offset; start < a.index + a.length; start++) {
+ int left = a.index;
+ int right = start;
+ void* pivot = a.list[right];
+
+ while (left < right) {
+ int p = left + ((right - left) >> 1);
+ if (lower_than (pivot, a.list[p])) {
+ right = p;
+ } else {
+ left = p + 1;
+ }
+ }
+ assert (left == right);
+
+ Memory.move (&a.list[left + 1], &a.list[left], sizeof (G) * (start - left));
+ a.list[left] = pivot;
+ }
+ }
+
+ private void merge_collapse () {
+ #if DEBUG
+ message ("Merge Collapse");
+ #endif
+ int count = pending.length;
+ while (count > 1) {
+ #if DEBUG
+ message ("Pending count: %d", count);
+ if (count >= 3) {
+ message ("pending[count-3]=%p; pending[count-2]=%p;
pending[count-1]=%p",
+ pending[count-3], pending[count-2], pending[count-1]);
+ }
+ #endif
+ if (count >= 3 && pending[count-3].length <= pending[count-2].length +
pending[count-1].length) {
+ if (pending[count-3].length < pending[count-1].length) {
+ merge_at (count-3);
+ } else {
+ merge_at (count-2);
+ }
+ } else if (pending[count-2].length <= pending[count-1].length) {
+ merge_at (count-2);
+ } else {
+ break;
+ }
+ count = pending.length;
+ #if DEBUG
+ message ("New pending count: %d", count);
+ #endif
+ }
+ }
+
+ private void merge_force_collapse () {
+ #if DEBUG
+ message ("Merge Force Collapse");
+ #endif
+ int count = pending.length;
+ #if DEBUG
+ message ("Pending count: %d", count);
+ #endif
+ while (count > 1) {
+ if (count >= 3 && pending[count-3].length < pending[count-1].length) {
+ merge_at (count-3);
+ } else {
+ merge_at (count-2);
+ }
+ count = pending.length;
+ #if DEBUG
+ message ("New pending count: %d", count);
+ #endif
+ }
+ }
+
+ private void merge_at (int index) {
+ #if DEBUG
+ message ("Merge at %d", index);
+ #endif
+ Slice<G> a = (owned) pending[index];
+ Slice<G> b = (owned) pending[index + 1];
+
+ assert (a.length > 0);
+ assert (b.length > 0);
+ assert (a.index + a.length == b.index);
+
+ pending[index] = new Slice<G> (list, a.index, a.length + b.length);
+ pending.move (index + 2, index + 1, pending.length - index - 2);
+ pending.length -= 1;
+
+ int sorted_count = gallop_rightmost (b.peek_first (), a, 0);
+ a.shorten_start (sorted_count);
+ if (a.length == 0) {
+ return;
+ }
+
+ b.length = gallop_leftmost (a.peek_last (), b, b.length - 1);
+ if (b.length == 0) {
+ return;
+ }
+
+ if (a.length <= b.length) {
+ merge_low ((owned) a, (owned) b);
+ } else {
+ merge_high ((owned) a, (owned) b);
+ }
+ }
+
+ private int gallop_leftmost (G key, Slice<G> a, int hint) {
+ #if DEBUG
+ message ("Galop leftmost in (%d, %d), hint=%d", a.index, a.length, hint);
+ #endif
+ assert (0 <= hint);
+ assert (hint < a.length);
+
+ int p = a.index + hint;
+ int last_offset = 0;
+ int offset = 1;
+ if (lower_than (a.list[p], key)) {
+ int max_offset = a.length - hint;
+ while (offset < max_offset) {
+ if (lower_than (a.list[p + offset], key)) {
+ last_offset = offset;
+ offset <<= 1;
+ offset++;
+ } else {
+ break;
+ }
+ }
+
+ if (offset > max_offset) {
+ offset = max_offset;
+ }
+
+ last_offset = hint + last_offset;
+ offset = hint + offset;
+ } else {
+ int max_offset = hint + 1;
+ while (offset < max_offset) {
+ if (lower_than (a.list[p - offset], key)) {
+ break;
+ } else {
+ last_offset = offset;
+ offset <<= 1;
+ offset++;
+ }
+ }
+
+ if (offset > max_offset) {
+ offset = max_offset;
+ }
+
+ int temp_last_offset = last_offset;
+ int temp_offset = offset;
+ last_offset = hint - temp_offset;
+ offset = hint - temp_last_offset;
+ }
+
+ assert (-1 <= last_offset);
+ assert (last_offset < offset);
+ assert (offset <= a.length);
+
+ last_offset += 1;
+ while (last_offset < offset) {
+ int m = last_offset + ((offset - last_offset) >> 1);
+ if (lower_than (a.list[a.index + m], key)) {
+ last_offset = m + 1;
+ } else {
+ offset = m;
+ }
+ }
+
+ assert (last_offset == offset);
+ return offset;
+ }
+
+ private int gallop_rightmost (G key, Slice<G> a, int hint) {
+ #if DEBUG
+ message ("Galop rightmost in (%d, %d), hint=%d", a.index, a.length, hint);
+ #endif
+ assert (0 <= hint);
+ assert (hint < a.length);
+
+ int p = a.index + hint;
+ int last_offset = 0;
+ int offset = 1;
+ if (lower_than_or_equal_to (a.list[p], key)) {
+ int max_offset = a.length - hint;
+ while (offset < max_offset) {
+ if (lower_than_or_equal_to (a.list[p + offset], key)) {
+ last_offset = offset;
+ offset <<= 1;
+ offset++;
+ } else {
+ break;
+ }
+ }
+
+ if (offset > max_offset) {
+ offset = max_offset;
+ }
+
+ last_offset = hint + last_offset;
+ offset = hint + offset;
+ } else {
+ int max_offset = hint + 1;
+ while (offset < max_offset) {
+ if (lower_than_or_equal_to (a.list[p - offset], key)) {
+ break;
+ } else {
+ last_offset = offset;
+ offset <<= 1;
+ offset++;
+ }
+ }
+
+ if (offset > max_offset) {
+ offset = max_offset;
+ }
+
+ int temp_last_offset = last_offset;
+ int temp_offset = offset;
+ last_offset = hint - temp_offset;
+ offset = hint - temp_last_offset;
+ }
+
+ assert (-1 <= last_offset);
+ assert (last_offset < offset);
+ assert (offset <= a.length);
+
+ last_offset += 1;
+ while (last_offset < offset) {
+ int m = last_offset + ((offset - last_offset) >> 1);
+ if (lower_than_or_equal_to (a.list[a.index + m], key)) {
+ last_offset = m + 1;
+ } else {
+ offset = m;
+ }
+ }
+
+ assert (last_offset == offset);
+ return offset;
+ }
+
+ private void merge_low (owned Slice<G> a, owned Slice<G> b) {
+ #if DEBUG
+ message ("Merge low (%d, %d) (%d, %d)", a.index, a.length, b.index, b.length);
+ #endif
+ assert (a.length > 0);
+ assert (b.length > 0);
+ assert (a.index + a.length == b.index);
+
+ int minimum_gallop = this.minimum_gallop;
+ int dest = a.index;
+ a.copy ();
+
+ try {
+ list[dest++] = b.pop_first ();
+ if (a.length == 1 || b.length == 0) {
+ return;
+ }
+
+ while (true) {
+ int a_count = 0;
+ int b_count = 0;
+
+ while (true) {
+ if (lower_than (b.peek_first (), a.peek_first ())) {
+ list[dest++] = b.pop_first ();
+ if (b.length == 0) {
+ return;
+ }
+
+ b_count++;
+ a_count = 0;
+ if (b_count >= minimum_gallop) {
+ break;
+ }
+ } else {
+ list[dest++] = a.pop_first ();
+ if (a.length == 1) {
+ return;
+ }
+
+ a_count++;
+ b_count = 0;
+ if (a_count >= minimum_gallop) {
+ break;
+ }
+ }
+ }
+
+ minimum_gallop++;
+
+ while (true) {
+ minimum_gallop -= (minimum_gallop > 1 ? 1 : 0);
+ this.minimum_gallop = minimum_gallop;
+
+ a_count = gallop_rightmost (b.peek_first (), a, 0);
+ a.merge_in (list, a.index, dest, a_count);
+ dest += a_count;
+ a.shorten_start (a_count);
+ if (a.length <= 1) {
+ return;
+ }
+
+ list[dest++] = b.pop_first ();
+ if (b.length == 0) {
+ return;
+ }
+
+ b_count = gallop_leftmost (a.peek_first (), b, 0);
+ b.merge_in (list, b.index, dest, b_count);
+ dest += b_count;
+ b.shorten_start (b_count);
+ if (b.length == 0) {
+ return;
+ }
+
+ list[dest++] = a.pop_first ();
+ if (a.length == 1) {
+ return;
+ }
+
+ if (a_count < MINIMUM_GALLOP && b_count < MINIMUM_GALLOP) {
+ break;
+ }
+ }
+
+ minimum_gallop++;
+ this.minimum_gallop = minimum_gallop;
+ }
+ } finally {
+ assert (a.length >= 0);
+ assert (b.length >= 0);
+ b.merge_in (list, b.index, dest, b.length);
+ a.merge_in (list, a.index, dest + b.length, a.length);
+ }
+ }
+
+ private void merge_high (owned Slice<G> a, owned Slice<G> b) {
+ #if DEBUG
+ message ("Merge high (%d, %d) (%d, %d)", a.index, a.length, b.index, b.length);
+ #endif
+ assert (a.length > 0);
+ assert (b.length > 0);
+ assert (a.index + a.length == b.index);
+
+ int minimum_gallop = this.minimum_gallop;
+ int dest = b.index + b.length;
+ b.copy ();
+
+ try {
+ list[--dest] = a.pop_last ();
+ if (a.length == 0 || b.length == 1) {
+ return;
+ }
+
+ while (true) {
+ int a_count = 0;
+ int b_count = 0;
+
+ while (true) {
+ if (lower_than (b.peek_last (), a.peek_last ())) {
+ list[--dest] = a.pop_last ();
+ if (a.length == 0) {
+ return;
+ }
+
+ a_count++;
+ b_count = 0;
+ if (a_count >= minimum_gallop) {
+ break;
+ }
+ } else {
+ list[--dest] = b.pop_last ();
+ if (b.length == 1) {
+ return;
+ }
+
+ b_count++;
+ a_count = 0;
+ if (b_count >= minimum_gallop) {
+ break;
+ }
+ }
+ }
+
+ minimum_gallop++;
+
+ while (true) {
+ minimum_gallop -= (minimum_gallop > 1 ? 1 : 0);
+ this.minimum_gallop = minimum_gallop;
+
+ int k = gallop_rightmost (b.peek_last (), a, a.length - 1);
+ a_count = a.length - k;
+ a.merge_in_reversed (list, a.index + k, dest - a_count, a_count);
+ dest -= a_count;
+ a.shorten_end (a_count);
+ if (a.length == 0) {
+ return;
+ }
+
+ list[--dest] = b.pop_last ();
+ if (b.length == 1) {
+ return;
+ }
+
+ k = gallop_leftmost (a.peek_last (), b, b.length - 1);
+ b_count = b.length - k;
+ b.merge_in_reversed (list, b.index + k, dest - b_count, b_count);
+ dest -= b_count;
+ b.shorten_end (b_count);
+ if (b.length <= 1) {
+ return;
+ }
+
+ list[--dest] = a.pop_last ();
+ if (a.length == 0) {
+ return;
+ }
+
+ if (a_count < MINIMUM_GALLOP && b_count < MINIMUM_GALLOP) {
+ break;
+ }
+ }
+
+ minimum_gallop++;
+ this.minimum_gallop = minimum_gallop;
+ }
+ } finally {
+ assert (a.length >= 0);
+ assert (b.length >= 0);
+ a.merge_in_reversed (list, a.index, dest - a.length, a.length);
+ b.merge_in_reversed (list, b.index, dest - a.length - b.length, b.length);
+ }
+ }
+
+ [Compact]
+ private class Slice<G> {
+
+ public void** list;
+ public void** new_list;
+ public int index;
+ public int length;
+
+ public Slice (void** list, int index, int length) {
+ this.list = list;
+ this.index = index;
+ this.length = length;
+ }
+
+ ~Slice () {
+ if (new_list != null)
+ free (new_list);
+ }
+
+ public void copy () {
+ new_list = Memory.dup (&list[index], (uint) sizeof (G) * length);
+ list = new_list;
+ index = 0;
+ }
+
+ public inline void merge_in (void** dest_array, int index, int dest_index, int count) {
+ Memory.move (&dest_array[dest_index], &list[index], sizeof (G) * count);
+ }
+
+ public inline void merge_in_reversed (void** dest_array, int index, int dest_index, int
count) {
+ Memory.move (&dest_array[dest_index], &list[index], sizeof (G) * count);
+ }
+
+ public inline void shorten_start (int n) {
+ index += n;
+ length -= n;
+ }
+
+ public inline void shorten_end (int n) {
+ length -= n;
+ }
+
+ public inline void* pop_first () {
+ length--;
+ return list[index++];
+ }
+
+ public inline void* pop_last () {
+ length--;
+ return list[index + length];
+ }
+
+ public inline unowned void* peek_first () {
+ return list[index];
+ }
+
+ public inline unowned void* peek_last () {
+ return list[index + length - 1];
+ }
+
+ public void reverse () {
+ int low = index;
+ int high = index + length - 1;
+ while (low < high) {
+ swap (low++, high--);
+ }
+ }
+
+ private inline void swap (int i, int j) {
+ void* temp = list[i];
+ list[i] = list[j];
+ list[j] = temp;
+ }
+ }
+}
+
diff --git a/gee/traversable.vala b/gee/traversable.vala
new file mode 100644
index 0000000..5589622
--- /dev/null
+++ b/gee/traversable.vala
@@ -0,0 +1,379 @@
+/* traversable.vala
+ *
+ * Copyright (C) 2011-2012 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+namespace Vala {
+ public delegate A FoldFunc<A, G> (owned G g, owned A a);
+ public delegate bool ForallFunc<G> (owned G g);
+ public delegate Lazy<A>? UnfoldFunc<A> ();
+ public delegate Traversable.Stream StreamFunc<G, A> (Traversable.Stream state, owned Lazy<G>? g, out
Lazy<A>? lazy);
+ public delegate A MapFunc<A, G> (owned G g);
+ public delegate bool Predicate<G> (G g);
+}
+
+/**
+ * It's a common interface for {@link Iterator} and {@link Iterable}. It
+ * provides a fast, high level functions.
+ *
+ * ''{@link Iterator} implementation:'' Please note that most of the functions
+ * affect the state of the iterator by moving it forward.
+ * Even if the iterator is {@link BidirIterator} it ''must not''
+ * rewind the state.
+ *
+ * ''{@link Iterable} implementation:'' validy ({@link Iterator.valid})
+ * of returned iterator is the same as for invalid
+ * iterator. In other words the following code is semantically equivalent:
+ *
+ * {{{
+ * var x = iterable.function (args);
+ * var x = iterable.iterator ().function(args);
+ * }}}
+ *
+ * @since 0.7.0
+ */
+[GenericAccessors]
+public interface Vala.Traversable<G> : Object {
+ /**
+ * Apply function to each element returned by iterator untill last element
+ * or function return ''false''.
+ *
+ * ''{@link Iterator} implementation:'' Operation moves the iterator
+ * to last element in iteration or the first element that returned ''false''.
+ * If iterator points at some element it will be included in iteration.
+ *
+ * @return ''false'' if the argument returned ''false'' at last invocation and
+ * ''true'' otherwise.
+ */
+ public new abstract bool foreach (ForallFunc<G> f);
+
+ /**
+ * Stream function is an abstract function allowing writing many
+ * operations.
+ *
+ * The stream function accepts three parameter:
+ *
+ * 1. state. It is usually the last returned value from function but
+ * it may be {@link Stream.END} when {@link Stream.CONTINUE} was
+ * returned and there was no more elements.
+ * 1. input. It is valid only if first argument is
+ * {@link Stream.CONTINUE}
+ * 1. output. It is valid only if result is Stream.YIELD
+ *
+ * It may return one of 3 results:
+ *
+ * 1. {@link Stream.YIELD}. It means that value was yielded and can
+ * be passed to outgoing iterator.
+ * 1. {@link Stream.CONTINUE}. It means that the function needs to be
+ * called with next element or with {@link Stream.END} if it is
+ * end of stream). If the state element was Stream.END during the
+ * current iteration function ''must not'' return {@link Stream.CONTINUE}
+ * 1. Stream.END. It means that the last argument was yielded.
+ *
+ * If the function yields the value immediately then the returning iterator
+ * is {@link Iterator.valid} and points to this value as well as in case when the
+ * parent iterator is {@link Iterator.valid} and function yields
+ * after consuming 1 input. In other case returned iterator is invalid.
+ *
+ * Note: In {@link Iterator} implementation: if iterator is
+ * {@link Iterator.valid} the current value should be fed
+ * immediately to function if during initial call function returns
+ * {@link Stream.CONTINUE}. The parent iterator cannot be used before
+ * the functions return {@link Stream.END} afterwards it points on the
+ * last element consumed.
+ *
+ * @param f function generating stream
+ * @return iterator containing values yielded by stream
+ */
+ public virtual Iterator<A> stream<A> (owned StreamFunc<G, A> f) {
+ Iterator<G>? self;
+ Iterable<G>? iself;
+ // Yes - I've heard of polimorphism ;) but I don't want users to need to implement the method.
+ if ((self = this as Iterator<G>) != null) {
+ Traversable.Stream str;
+ Lazy<A>? initial = null;
+ bool need_next = true;
+ str = f (Stream.YIELD, null, out initial);
+ switch (str) {
+ case Stream.CONTINUE:
+ if (self.valid) {
+ str = f (Stream.CONTINUE, new Lazy<G> (() => {return self.get ();}),
out initial);
+ switch (str) {
+ case Stream.YIELD:
+ case Stream.CONTINUE:
+ break;
+ case Stream.END:
+ return Iterator.unfold<A> (() => {return null;});
+ default:
+ assert_not_reached ();
+ }
+ }
+ break;
+ case Stream.YIELD:
+ if (self.valid)
+ need_next = false;
+ break;
+ case Stream.END:
+ return Iterator.unfold<A> (() => {return null;});
+ default:
+ assert_not_reached ();
+ }
+ return Iterator.unfold<A> (() => {
+ Lazy<A>? val = null;
+ if (str != Stream.CONTINUE)
+ str = f (Traversable.Stream.YIELD, null, out val);
+ while (str == Stream.CONTINUE) {
+ if (need_next) {
+ if (!self.next ()) {
+ str = f (Traversable.Stream.END, null, out val);
+ assert (str != Traversable.Stream.CONTINUE);
+ break;
+ }
+ } else {
+ need_next = true;
+ }
+ str = f (Stream.CONTINUE, new Lazy<G> (() => {return self.get ();}),
out val);
+ }
+ switch (str) {
+ case Stream.YIELD:
+ return val;
+ case Stream.END:
+ return null;
+ default:
+ assert_not_reached ();
+ }
+ }, initial);
+ } else if ((iself = this as Iterable<G>) != null) {
+ return iself.iterator().stream<A> ((owned) f);
+ } else {
+ assert_not_reached ();
+ }
+ }
+
+ /**
+ * Standard aggregation function.
+ *
+ * It takes a function, seed and first element, returns the new seed and
+ * progress to next element when the operation repeats.
+ *
+ * Note: Default implementation uses {@link foreach}.
+ *
+ * Note: In {@link Iterator} implementation operation moves the
+ * iterator to last element in iteration. If iterator is
+ * {@link Iterator.valid} the current element will be considered
+ * as well.
+ *
+ */
+ public virtual A fold<A> (FoldFunc<A, G> f, owned A seed)
+ {
+ this.foreach ((item) => {seed = f ((owned) item, (owned) seed); return true; });
+ return (owned) seed;
+ }
+
+ /**
+ * Produces an iterator pointing at elements generated by function passed.
+ *
+ * Iterator is lazy evaluated but value is force-evaluated when
+ * iterator moves to next element. ({@link Iterator.next})
+ *
+ * Note: Default implementation uses {@link stream}.
+ *
+ * Note: In {@link Iterator} implementation if the parent iterator is
+ * {@link Iterator.valid} so is the returned one. Using the parent
+ * iterator is not allowed before the inner iterator {@link Iterator.next}
+ * return false and then it points on its last element.
+ * The resulting iterator is {@link Iterator.valid} if the parent
+ * iterator is.
+ *
+ * @param f Mapping function
+ * @return Iterator listing mapped value
+ */
+ public virtual Iterator<A> map<A> (MapFunc<A, G> f) {
+ return stream<A>((state, item, out val) => {
+ switch (state) {
+ case Stream.YIELD:
+ val = null;
+ return Stream.CONTINUE;
+ case Stream.CONTINUE:
+ val = new Lazy<A>(() => {
+ A tmp = item.get ();
+ item = null;
+ return (f ((owned)tmp));
+ });
+ return Stream.YIELD;
+ case Stream.END:
+ val = null;
+ return Stream.END;
+ default:
+ assert_not_reached ();
+ }
+ });
+ }
+
+ /**
+ * Creates a new iterator that is initially pointing to seed. Then
+ * subsequent values are obtained after applying the function to previous
+ * value and the subsequent items.
+ *
+ * The resulting iterator is always valid and it contains the seed value.
+ *
+ * Note: Default implementation uses {@link stream}.
+ *
+ * Note: When the method is called on {@link Iterator} using the parent
+ * iterator is not allowed befor the inner iterator
+ * {@link Iterator.next} return false and then it points on its last
+ * element. The resulting iterator is {@link Iterator.valid}.
+ *
+ * @param f Folding function
+ * @param seed original seed value
+ * @return Iterator containing values of subsequent values of seed
+ */
+ public virtual Iterator<A> scan<A> (FoldFunc<A, G> f, owned A seed) {
+ bool seed_emitted = false;
+ return stream<A>((state, item, out val) => {
+ switch (state) {
+ case Stream.YIELD:
+ if (seed_emitted) {
+ val = null;
+ return Stream.CONTINUE;
+ } else {
+ val = new Lazy<A>.from_value (seed);
+ seed_emitted = true;
+ return Stream.YIELD;
+ }
+ case Stream.CONTINUE:
+ val = new Lazy<A> (() => {
+ A tmp = item.get ();
+ item = null;
+ seed = f ((owned) tmp, (owned) seed);
+ return seed;
+ });
+ return Stream.YIELD;
+ case Stream.END:
+ val = null;
+ return Stream.END;
+ default:
+ assert_not_reached ();
+ }
+ });
+ }
+
+ /**
+ * Creates a new iterator that contains only values that fullfills the
+ * predicate.
+ *
+ * Note: When the method is called on {@link Iterator} using the parent
+ * iterator is not allowed befor the inner iterator
+ * {@link Iterator.next} return false and then it points on its last
+ * element. The resulting iterator is {@link Iterator.valid} if parent
+ * iterator is {@link Iterator.valid} and value it is pointing on
+ * fullfills the predicate.
+ *
+ * @param f Folding function
+ * @return Iterator containing values of subsequent values of seed
+ */
+ public virtual Iterator<G> filter (owned Predicate<G> pred) {
+ return stream<G> ((state, item, out val) => {
+ switch (state) {
+ case Stream.YIELD:
+ val = null;
+ return Stream.CONTINUE;
+ case Stream.CONTINUE:
+ G g = item.get ();
+ if (pred (g)) {
+ val = item;
+ return Stream.YIELD;
+ } else {
+ val = null;
+ return Stream.CONTINUE;
+ }
+ case Stream.END:
+ val = null;
+ return Stream.END;
+ default:
+ assert_not_reached ();
+ };
+ });
+ }
+
+ /**
+ * Creates a new iterator which contains elements from iterable. The
+ * first argument states the offset i.e. number of elements the iterator
+ * skips by default.
+ *
+ * Note: In {@link Iterator} implementation resulting iterator is
+ * {@link Iterator.valid} when parent iterator is
+ * {@link Iterator.valid} and the offset is 0. Using the parent
+ * iterator is not allowed before the inner iterator
+ * {@link Iterator.next} return false and then it points on its last
+ * element.
+ *
+ * @param offset the offset to first element the iterator is pointing to
+ * @param length maximum number of elements iterator may return. Negative
+ * value means that the number is unbounded
+ */
+ public virtual Iterator<G> chop (int offset, int length = -1) {
+ assert (offset >= 0);
+ return stream<G> ((state, item, out val) => {
+ switch (state) {
+ case Stream.YIELD:
+ val = null;
+ if (offset > 0) {
+ return Stream.CONTINUE;
+ } else if (length > 0) {
+ return length != 0 ? Stream.CONTINUE : Stream.END;
+ } else if (length == 0) {
+ return Stream.END;
+ } else {
+ return Stream.CONTINUE;
+ }
+ case Stream.CONTINUE:
+ if (offset == 0) {
+ val = item;
+ length--;
+ return Stream.YIELD;
+ } else {
+ val = null;
+ offset--;
+ return Stream.CONTINUE;
+ }
+ case Stream.END:
+ val = null;
+ return Stream.END;
+ default:
+ assert_not_reached ();
+ };
+ });
+ }
+
+
+ /**
+ * The type of the elements in this collection.
+ */
+ public virtual Type element_type { get { return typeof (G); } }
+
+ public enum Stream {
+ YIELD,
+ CONTINUE,
+ END
+ }
+
+}
+
diff --git a/gee/treemap.vala b/gee/treemap.vala
new file mode 100644
index 0000000..bba4809
--- /dev/null
+++ b/gee/treemap.vala
@@ -0,0 +1,1914 @@
+/* treemap.vala
+ *
+ * Copyright (C) 2009-2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+using GLib;
+
+/**
+ * Left-leaning red-black tree implementation of the {@link Map} interface.
+ *
+ * This implementation is especially well designed for large quantity of
+ * data. The (balanced) tree implementation insure that the set and get
+ * methods are in logarithmic complexity.
+ *
+ * @see HashMap
+ */
+public class Vala.TreeMap<K,V> : Vala.AbstractBidirSortedMap<K,V> {
+ /**
+ * {@inheritDoc}
+ */
+ public override int size {
+ get { return _size; }
+ }
+
+ public override bool read_only {
+ get { return false; }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Set<K> keys {
+ owned get {
+ var keys = _keys;
+ if (_keys == null) {
+ keys = new KeySet<K,V> (this);
+ _keys = keys;
+ keys.add_weak_pointer ((void**) (&_keys));
+ }
+ return keys;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Collection<V> values {
+ owned get {
+ var values = _values;
+ if (_values == null) {
+ values = new ValueCollection<K,V> (this);
+ _values = values;
+ values.add_weak_pointer ((void**) (&_values));
+ }
+ return values;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Set<Map.Entry<K,V>> entries {
+ owned get {
+ var entries = _entries;
+ if (_entries == null) {
+ entries = new EntrySet<K,V> (this);
+ _entries = entries;
+ entries.add_weak_pointer ((void**) (&_entries));
+ }
+ return entries;
+ }
+ }
+
+ /**
+ * The keys' comparator function.
+ */
+ [CCode (notify = false)]
+ public CompareDataFunc<K> key_compare_func { private set; get; }
+
+ /**
+ * The values' equality testing function.
+ */
+ [CCode (notify = false)]
+ public EqualDataFunc<V> value_equal_func { private set; get; }
+
+ private int _size = 0;
+
+ private weak SortedSet<K> _keys;
+ private weak Collection<V> _values;
+ private weak SortedSet<Map.Entry<K,V>> _entries;
+
+ /**
+ * Constructs a new, empty tree map sorted according to the specified
+ * comparator function.
+ *
+ * If not provided, the functions parameters are requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param key_compare_func an optional key comparator function
+ * @param value_equal_func an optional values equality testing function
+ */
+ public TreeMap (owned CompareDataFunc<K>? key_compare_func = null, owned EqualDataFunc<V>?
value_equal_func = null) {
+ if (key_compare_func == null) {
+ key_compare_func = Functions.get_compare_func_for (typeof (K));
+ }
+ if (value_equal_func == null) {
+ value_equal_func = Functions.get_equal_func_for (typeof (V));
+ }
+ this.key_compare_func = key_compare_func;
+ this.value_equal_func = value_equal_func;
+ }
+
+ ~TreeMap () {
+ clear ();
+ }
+
+ private void rotate_right (ref Node<K, V> root) {
+ Node<K,V> pivot = (owned) root.left;
+ pivot.color = root.color;
+ root.color = Node.Color.RED;
+ root.left = (owned) pivot.right;
+ pivot.right = (owned) root;
+ root = (owned) pivot;
+ }
+
+ private void rotate_left (ref Node<K, V> root) {
+ Node<K,V> pivot = (owned) root.right;
+ pivot.color = root.color;
+ root.color = Node.Color.RED;
+ root.right = (owned) pivot.left;
+ pivot.left = (owned) root;
+ root = (owned) pivot;
+ }
+
+ private bool is_red (Node<K, V>? n) {
+ return n != null && n.color == Node.Color.RED;
+ }
+
+ private bool is_black (Node<K, V>? n) {
+ return n == null || n.color == Node.Color.BLACK;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool has_key (K key) {
+ weak Node<K, V>? cur = root;
+ while (cur != null) {
+ int res = key_compare_func (key, cur.key);
+ if (res == 0) {
+ return true;
+ } else if (res < 0) {
+ cur = cur.left;
+ } else {
+ cur = cur.right;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool has (K key, V value) {
+ V? own_value = get (key);
+ return (own_value != null && value_equal_func (own_value, value));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override V? get (K key) {
+ weak Node<K, V>? cur = root;
+ while (cur != null) {
+ int res = key_compare_func (key, cur.key);
+ if (res == 0) {
+ return cur.value;
+ } else if (res < 0) {
+ cur = cur.left;
+ } else {
+ cur = cur.right;
+ }
+ }
+ return null;
+ }
+
+ private bool set_to_node (ref Node<K, V>? node, K key, V value, out V? old_value, Node<K, V>? prev,
Node<K, V>? next) {
+ if (node == null) {
+ old_value = null;
+ node = new Node<K,V> (key, value, prev, next);
+ if (prev == null) {
+ first = node;
+ }
+ if (next == null) {
+ last = node;
+ }
+ _size++;
+ return true;
+ }
+
+ int cmp = key_compare_func (key, node.key);
+ bool changed;
+ if (cmp == 0) {
+ if (value_equal_func (value, node.value)) {
+ old_value = null;
+ changed = false;
+ } else {
+ old_value = (owned) node.value;
+ node.value = value;
+ changed = true;
+ }
+ } else if (cmp < 0) {
+ changed = set_to_node (ref node.left, key, value, out old_value, node.prev, node);
+ } else {
+ changed = set_to_node (ref node.right, key, value, out old_value, node, node.next);
+ }
+
+ fix_up (ref node);
+ return changed;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void set (K key, V value) {
+ V old_value;
+ set_to_node (ref root, key, value, out old_value, null, null);
+ root.color = Node.Color.BLACK;
+ stamp++;
+ }
+
+ private void move_red_left (ref Node<K, V> root) {
+ root.flip ();
+ if (is_red (root.right.left)) {
+ rotate_right (ref root.right);
+ rotate_left (ref root);
+ root.flip ();
+ }
+ }
+
+ private void move_red_right (ref Node<K, V> root) {
+ root.flip ();
+ if (is_red (root.left.left)) {
+ rotate_right (ref root);
+ root.flip ();
+ }
+ }
+
+ private void fix_removal (ref Node<K,V> node, out K? key = null, out V? value = null) {
+ Node<K,V> n = (owned) node;
+ key = (owned) n.key;
+ value = (owned) n.value;
+ if (n.prev != null) {
+ n.prev.next = n.next;
+ } else {
+ first = n.next;
+ }
+ if (n.next != null) {
+ n.next.prev = n.prev;
+ } else {
+ last = n.next;
+ }
+ n.value = null;
+ node = null;
+ _size--;
+ }
+
+ private void remove_minimal (ref Node<K,V> node, out K key, out V value) {
+ if (node.left == null) {
+ fix_removal (ref node, out key, out value);
+ return;
+ }
+
+ if (is_black (node.left) && is_black (node.left.left)) {
+ move_red_left (ref node);
+ }
+
+ remove_minimal (ref node.left, out key, out value);
+
+ fix_up (ref node);
+ }
+
+ private bool remove_from_node (ref Node<K, V>? node, K key, out V? value, out unowned Node<K, V>?
prev = null, out unowned Node<K, V>? next = null) {
+ if (node == null) {
+ value = null;
+ next = null;
+ prev = null;
+ return false;
+ } else if (key_compare_func (key, node.key) < 0) {
+ weak Node<K,V> left = node.left;
+ if (left == null) {
+ value = null;
+ next = null;
+ prev = null;
+ return false;
+ }
+ if (node.left != null && is_black (left) && is_black (left.left)) {
+ move_red_left (ref node);
+ }
+ bool r = remove_from_node (ref node.left, key, out value, out prev, out next);
+ fix_up (ref node);
+ return r;
+ } else {
+ if (is_red (node.left)) {
+ rotate_right (ref node);
+ }
+
+ weak Node<K,V>? r = node.right;
+ if (key_compare_func (key, node.key) == 0 && r == null) {
+ prev = node.prev;
+ next = node.next;
+ fix_removal (ref node, null, out value);
+ return true;
+ }
+ if (is_black (r) && r != null && is_black (r.left)) {
+ move_red_right (ref node);
+ }
+ if (key_compare_func (key, node.key) == 0) {
+ value = (owned) node.value;
+ prev = node.prev;
+ next = node;
+ remove_minimal (ref node.right, out node.key, out node.value);
+ fix_up (ref node);
+ return true;
+ } else {
+ bool re = remove_from_node (ref node.right, key, out value, out prev, out
next);
+ fix_up (ref node);
+ return re;
+ }
+ }
+ }
+
+ private void fix_up (ref Node<K,V> node) {
+ if (is_black (node.left) && is_red (node.right)) {
+ rotate_left (ref node);
+ }
+ if (is_red (node.left) && is_red (node.left.left)) {
+ rotate_right (ref node);
+ }
+ if (is_red (node.left) && is_red (node.right)) {
+ node.flip ();
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool unset (K key, out V? value = null) {
+ bool b = remove_from_node (ref root, key, out value);
+
+ if (root != null) {
+ root.color = Node.Color.BLACK;
+ }
+ stamp++;
+ return b;
+ }
+
+ private inline void clear_subtree (owned Node<K,V> node) {
+ node.key = null;
+ node.value = null;
+ if (node.left != null)
+ clear_subtree ((owned) node.left);
+ if (node.right != null)
+ clear_subtree ((owned) node.right);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void clear () {
+ if (root != null) {
+ clear_subtree ((owned) root);
+ first = last = null;
+ }
+ _size = 0;
+ stamp++;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override SortedMap<K,V> head_map (K before) {
+ return new SubMap<K,V> (this, new Range<K,V>.head (this, before));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override SortedMap<K,V> tail_map (K after) {
+ return new SubMap<K,V> (this, new Range<K,V>.tail (this, after));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override SortedMap<K,V> sub_map (K after, K before) {
+ return new SubMap<K,V> (this, new Range<K,V> (this, after, before));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override SortedSet<K> ascending_keys {
+ owned get {
+ var keys = _keys;
+ if (_keys == null) {
+ keys = new KeySet<K,V> (this);
+ _keys = keys;
+ keys.add_weak_pointer (&_keys);
+ }
+ return keys;
+ }
+ }
+ /**
+ * {@inheritDoc}
+ */
+ public override SortedSet<Map.Entry<K,V>> ascending_entries {
+ owned get {
+ var entries = _entries;
+ if (_entries == null) {
+ entries = new EntrySet<K,V> (this);
+ _entries = entries;
+ entries.add_weak_pointer (&_entries);
+ }
+ return entries;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.MapIterator<K,V> map_iterator () {
+ return new MapIterator<K,V> (this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.BidirMapIterator<K,V> bidir_map_iterator () {
+ return new MapIterator<K,V> (this);
+ }
+
+ [Compact]
+ private class Node<K, V> {
+ public enum Color {
+ RED,
+ BLACK;
+
+ public Color flip () {
+ if (this == RED) {
+ return BLACK;
+ } else {
+ return RED;
+ }
+ }
+ }
+
+ public Node (owned K key, owned V value, Node<K,V>? prev, Node<K,V>? next) {
+ this.key = (owned) key;
+ this.value = (owned) value;
+ this.color = Color.RED;
+ this.prev = prev;
+ this.next = next;
+ if (prev != null) {
+ prev.next = this;
+ }
+ if (next != null) {
+ next.prev = this;
+ }
+ }
+
+ public void flip () {
+ color = color.flip ();
+ if (left != null) {
+ left.color = left.color.flip ();
+ }
+ if (right != null) {
+ right.color = right.color.flip ();
+ }
+ }
+
+ public K key;
+ public V value;
+ public Color color;
+ public Node<K, V>? left;
+ public Node<K, V>? right;
+ public weak Node<K, V>? prev;
+ public weak Node<K, V>? next;
+ public unowned Map.Entry<K,V>? entry;
+ }
+
+ private Node<K, V>? root = null;
+ private weak Node<K, V>? first = null;
+ private weak Node<K, V>? last = null;
+ private int stamp = 0;
+
+ private inline K min (K a, K b) {
+ return key_compare_func (a, b) <= 0 ? a : b;
+ }
+
+ private inline K max (K a, K b) {
+ return key_compare_func (a, b) > 0 ? a : b;
+ }
+
+ private inline unowned Node<K,V>? find_node (K key) {
+ unowned Node<K,V>? cur = root;
+ while (cur != null) {
+ int res = key_compare_func (key, cur.key);
+ if (res == 0) {
+ return cur;
+ } else if (res < 0) {
+ cur = cur.left;
+ } else {
+ cur = cur.right;
+ }
+ }
+ return null;
+ }
+
+ private inline unowned Node<K,V>? find_nearest (K key) {
+ unowned Node<K,V>? cur = root;
+ while (cur != null) {
+ int res = key_compare_func (key, cur.key);
+ if (res == 0) {
+ return cur;
+ } else if (res < 0) {
+ if (cur.left == null)
+ return cur;
+ cur = cur.left;
+ } else {
+ if (cur.right == null)
+ return cur;
+ cur = cur.right;
+ }
+ }
+ return null;
+ }
+
+ private class Entry<K,V> : Map.Entry<K,V> {
+ private unowned Node<K,V> _node;
+
+ public static Map.Entry<K,V> entry_for<K,V> (Node<K,V> node) {
+ Map.Entry<K,V> result = node.entry;
+ if (result == null) {
+ result = new Entry<K,V> (node);
+ node.entry = result;
+ result.add_weak_pointer ((void**) (&node.entry));
+ }
+ return result;
+ }
+
+ public Entry (Node<K,V> node) {
+ _node = node;
+ }
+
+ public override K key { get { return _node.key; } }
+
+ public override V value {
+ get { return _node.value; }
+ set { _node.value = value; }
+ }
+
+ public override bool read_only { get { return false; } }
+ }
+
+ private inline unowned Node<K,V>? find_lower (K key) {
+ unowned Node<K,V>? node = find_nearest (key);
+ if (node == null)
+ return null;
+ return key_compare_func (key, node.key) <= 0 ? node.prev : node;
+ }
+
+ private inline unowned Node<K,V>? find_higher (K key) {
+ unowned Node<K,V>? node = find_nearest (key);
+ if (node == null)
+ return null;
+ return key_compare_func (key, node.key) >= 0 ? node.next : node;
+ }
+
+ private inline unowned Node<K,V>? find_floor (K key) {
+ unowned Node<K,V>? node = find_nearest (key);
+ if (node == null)
+ return null;
+ return key_compare_func (key, node.key) < 0 ? node.prev : node;
+ }
+
+ private inline unowned Node<K,V>? find_ceil (K key) {
+ unowned Node<K,V>? node = find_nearest (key);
+ if (node == null)
+ return null;
+ return key_compare_func (key, node.key) > 0 ? node.next : node;
+ }
+
+ private inline K? lift_null_key (Node<K,V>? node) {
+ return node != null ? node.key : null;
+ }
+
+ private class Range<K,V> {
+ public Range (TreeMap<K,V> map, K after, K before) {
+ this.map = map;
+ if (map.key_compare_func (after, before) < 0) {
+ this.after = after;
+ this.before = before;
+ type = RangeType.BOUNDED;
+ } else {
+ type = RangeType.EMPTY;
+ }
+ }
+
+ public Range.head (TreeMap<K,V> map, K before) {
+ this.map = map;
+ this.before = before;
+ type = RangeType.HEAD;
+ }
+
+ public Range.tail (TreeMap<K,V> map, K after) {
+ this.map = map;
+ this.after = after;
+ type = RangeType.TAIL;
+ }
+
+ public Range.empty (TreeMap<K,V> map) {
+ this.map = map;
+ type = RangeType.EMPTY;
+ }
+
+ public Range<K,V> cut_head (K after) {
+ switch (type) {
+ case RangeType.HEAD:
+ return new Range<K,V> (map, after, before);
+ case RangeType.TAIL:
+ return new Range<K,V>.tail (map, map.max (after, this.after));
+ case RangeType.EMPTY:
+ return this;
+ case RangeType.BOUNDED:
+ var _after = map.max (after, this.after);
+ return new Range<K,V> (map, _after, before);
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ public Range<K,V> cut_tail (K before) {
+ switch (type) {
+ case RangeType.HEAD:
+ return new Range<K,V>.head (map, map.min (before, this.before));
+ case RangeType.TAIL:
+ return new Range<K,V> (map, after, before);
+ case RangeType.EMPTY:
+ return this;
+ case RangeType.BOUNDED:
+ var _before = map.min (before, this.before);
+ return new Range<K,V> (map, after, _before);
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ public Range<K,V> cut (K after, K before) {
+ if (type == RangeType.EMPTY)
+ return this;
+ var _before = (type == RangeType.HEAD || type == RangeType.BOUNDED) ?
+ map.min (before, this.before) : before;
+ var _after = (type == RangeType.TAIL || type == RangeType.BOUNDED) ?
+ map.max (after, this.after) : after;
+ return new Range<K,V> (map, _after, _before);
+ }
+
+ public bool in_range (K key) {
+ return type == RangeType.EMPTY ? false : compare_range(key) == 0;
+ }
+
+ public int compare_range (K key) {
+ switch (type) {
+ case RangeType.HEAD:
+ return map.key_compare_func (key, before) < 0 ? 0 : 1;
+ case RangeType.TAIL:
+ return map.key_compare_func (key, after) >= 0 ? 0 : -1;
+ case RangeType.EMPTY:
+ return 0; // For simplicity - please make sure it does not break anything
+ case RangeType.BOUNDED:
+ return map.key_compare_func (key, after) >= 0 ?
+ (map.key_compare_func (key, before) < 0 ? 0 : 1) : -1;
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ public bool empty_submap () {
+ switch (type) {
+ case RangeType.HEAD:
+ return map.first == null || !in_range (map.first.key);
+ case RangeType.TAIL:
+ return map.last == null || !in_range (map.last.key);
+ case RangeType.EMPTY:
+ return true;
+ case RangeType.BOUNDED:
+ return first () == null;
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ public unowned Node<K,V>? first () {
+ switch (type) {
+ case RangeType.EMPTY:
+ return null;
+ case RangeType.HEAD:
+ return map.first;
+ default:
+ return map.find_floor (after);
+ }
+ }
+
+ public unowned Node<K,V>? last () {
+ switch (type) {
+ case RangeType.EMPTY:
+ return null;
+ case RangeType.TAIL:
+ return map.last;
+ default:
+ return map.find_lower (before);
+ }
+ }
+
+ private new TreeMap<K,V> map;
+ private K after;
+ private K before;
+ private RangeType type;
+ }
+
+ private enum RangeType {
+ HEAD,
+ TAIL,
+ EMPTY,
+ BOUNDED
+ }
+
+ private class SubMap<K,V> : AbstractBidirSortedMap<K,V> {
+ public override int size { get { return keys.size; } }
+ public bool is_empty { get { return keys.is_empty; } }
+
+ public SubMap (TreeMap<K,V> map, Range<K,V> range) {
+ this.map = map;
+ this.range = range;
+ }
+
+ private weak SortedSet<K>? _keys;
+ public override Set<K> keys {
+ owned get {
+ var keys = _keys;
+ if (_keys == null) {
+ keys = new SubKeySet<K,V> (map, range);
+ _keys = keys;
+ keys.add_weak_pointer(&_keys);
+ }
+ return keys;
+ }
+ }
+
+ private weak Collection<K>? _values;
+ public override Collection<V> values {
+ owned get {
+ var values = _values;
+ if (_values == null) {
+ values = new SubValueCollection<K,V> (map, range);
+ _values = values;
+ values.add_weak_pointer(&_values);
+ }
+ return values;
+ }
+ }
+
+ private weak SortedSet<Entry<K,V>>? _entries;
+ public override Set<Entry<K,V>> entries {
+ owned get {
+ var entries = _entries;
+ if (_entries == null) {
+ entries = new SubEntrySet<K,V> (map, range);
+ _entries = entries;
+ entries.add_weak_pointer(&_entries);
+ }
+ return entries;
+ }
+ }
+
+ public override bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public override bool has_key (K key) {
+ return range.in_range (key) && map.has_key (key);
+ }
+
+ public override bool has (K key, V value) {
+ return range.in_range (key) && map.has (key, value);
+ }
+
+ public override new V? get (K key) {
+ return range.in_range (key) ? map.get (key) : null;
+ }
+
+ public override void set (K key, V value) {
+ if (range.in_range (key))
+ map.set (key, value);
+ }
+
+ public override bool unset (K key, out V? value = null) {
+ value = null;
+ return range.in_range (key) && map.unset (key, out value);
+ }
+
+ public override void clear () {
+ for (var iterator = map_iterator (); iterator.next ();)
+ iterator.unset ();
+ }
+
+ public override Vala.MapIterator<K,V> map_iterator () {
+ return new SubMapIterator<K,V> (map, range);
+ }
+
+ public override BidirMapIterator<K,V> bidir_map_iterator () {
+ return new SubMapIterator<K,V> (map, range);
+ }
+
+ public override SortedMap<K,V> head_map (K before) {
+ return new SubMap<K,V> (map, range.cut_tail (before));
+ }
+
+ public override SortedMap<K,V> tail_map (K after) {
+ return new SubMap<K,V> (map, range.cut_head (after));
+ }
+
+ public override SortedMap<K,V> sub_map (K after, K before) {
+ return new SubMap<K,V> (map, range.cut (after, before));
+ }
+
+ public override SortedSet<K> ascending_keys {
+ owned get {
+ var keys = _keys;
+ if (_keys == null) {
+ keys = new SubKeySet<K,V> (map, range);
+ _keys = keys;
+ keys.add_weak_pointer(&_keys);
+ }
+ return keys;
+ }
+ }
+
+ public override SortedSet<K> ascending_entries {
+ owned get {
+ var entries = _entries;
+ if (_entries == null) {
+ entries = new SubEntrySet<K,V> (map, range);
+ _entries = entries;
+ entries.add_weak_pointer(&_entries);
+ }
+ return _entries;
+ }
+ }
+
+ private TreeMap<K,V> map;
+ private Range<K,V> range;
+ }
+
+ private class KeySet<K,V> : AbstractBidirSortedSet<K> {
+ private TreeMap<K,V> _map;
+
+ public KeySet (TreeMap<K,V> map) {
+ _map = map;
+ }
+
+ public override Iterator<K> iterator () {
+ return new KeyIterator<K,V> (_map);
+ }
+
+ public override int size {
+ get { return _map.size; }
+ }
+
+ public override bool read_only {
+ get { return true; }
+ }
+
+ public override bool add (K key) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public override bool remove (K key) {
+ assert_not_reached ();
+ }
+
+ public override bool contains (K key) {
+ return _map.has_key (key);
+ }
+
+ public override K first () {
+ assert (_map.first != null);
+ return _map.first.key;
+ }
+
+ public override K last () {
+ assert (_map.last != null);
+ return _map.last.key;
+ }
+
+ public override BidirIterator<K> bidir_iterator () {
+ return new KeyIterator<K,V> (_map);
+ }
+
+ public override SortedSet<K> head_set (K before) {
+ return new SubKeySet<K,V> (_map, new Range<K,V>.head (_map, before));
+ }
+
+ public override SortedSet<K> tail_set (K after) {
+ return new SubKeySet<K,V> (_map, new Range<K,V>.tail (_map, after));
+ }
+
+ public override SortedSet<K> sub_set (K after, K before) {
+ return new SubKeySet<K,V> (_map, new Range<K,V> (_map, after, before));
+ }
+
+ public override Iterator<K>? iterator_at (K item) {
+ weak Node<K,V>? node = _map.find_node (item);
+ if (node == null)
+ return null;
+ return new KeyIterator<K,V>.pointing (_map, node);
+ }
+
+ public override K? lower (K item) {
+ return _map.lift_null_key (_map.find_lower (item));
+ }
+
+ public override K? higher (K item) {
+ return _map.lift_null_key (_map.find_higher (item));
+ }
+
+ public override K? floor (K item) {
+ return _map.lift_null_key (_map.find_floor (item));
+ }
+
+ public override K? ceil (K item) {
+ return _map.lift_null_key (_map.find_ceil (item));
+ }
+ }
+
+ private class SubKeySet<K,V> : AbstractBidirSortedSet<K> {
+ [CCode (notify = false)]
+ public TreeMap<K,V> map { private set; get; }
+ [CCode (notify = false)]
+ public Range<K,V> range { private set; get; }
+
+ public SubKeySet (TreeMap<K,V> map, Range<K,V> range) {
+ this.map = map;
+ this.range = range;
+ }
+
+ public override Iterator<K> iterator () {
+ return new SubKeyIterator<K,V> (map, range);
+ }
+
+ public override int size {
+ get {
+ var i = 0;
+ Vala.Iterator<K> iterator = iterator ();
+ while (iterator.next ())
+ i++;
+ return i;
+ }
+ }
+
+ public override bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public bool is_empty { get { return range.empty_submap (); } }
+
+ public override bool add (K key) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public override bool remove (K key) {
+ assert_not_reached ();
+ }
+
+ public override bool contains (K key) {
+ return range.in_range(key) && map.has_key (key);
+ }
+
+ public override BidirIterator<K> bidir_iterator () {
+ return new SubKeyIterator<K,V> (map, range);
+ }
+
+ public override K first () {
+ weak Node<K,V>? _first = range.first ();
+ assert (_first != null);
+ return _first.key;
+ }
+
+ public override K last () {
+ weak Node<K,V>? _last = range.last ();
+ assert (_last != null);
+ return _last.key;
+ }
+
+ public override SortedSet<K> head_set (K before) {
+ return new SubKeySet<K,V> (map, range.cut_tail (before));
+ }
+
+ public override SortedSet<K> tail_set (K after) {
+ return new SubKeySet<K,V> (map, range.cut_head (after));
+ }
+
+ public override SortedSet<K> sub_set (K after, K before) {
+ return new SubKeySet<K,V> (map, range.cut (after, before));
+ }
+
+ public override Iterator<K>? iterator_at (K key) {
+ if (!range.in_range (key))
+ return null;
+ weak Node<K,V>? n = map.find_node (key);
+ if (n == null)
+ return null;
+ return new SubKeyIterator<K,V>.pointing (map, range, n);
+ }
+
+ public override K? lower (K key) {
+ var res = range.compare_range (key);
+ if (res > 0)
+ return last ();
+ var l = map.lift_null_key (map.find_lower (key));
+ return l != null && range.in_range (l) ? l : null;
+ }
+
+ public override K? higher (K key) {
+ var res = range.compare_range (key);
+ if (res < 0)
+ return first ();
+ var h = map.lift_null_key (map.find_higher (key));
+ return h != null && range.in_range (h) ? h : null;
+ }
+
+ public override K? floor (K key) {
+ var res = range.compare_range (key);
+ if (res > 0)
+ return last ();
+ var l = map.lift_null_key (map.find_floor (key));
+ return l != null && range.in_range (l) ? l : null;
+ }
+
+ public override K? ceil (K key) {
+ var res = range.compare_range (key);
+ if (res < 0)
+ return first ();
+ var h = map.lift_null_key (map.find_ceil (key));
+ return h != null && range.in_range (h) ? h : null;
+ }
+ }
+
+ private class ValueCollection<K,V> : AbstractCollection<V> {
+ private TreeMap<K,V> _map;
+
+ public ValueCollection (TreeMap<K,V> map) {
+ _map = map;
+ }
+
+ public override Iterator<V> iterator () {
+ return new ValueIterator<K,V> (_map);
+ }
+
+ public override int size {
+ get { return _map.size; }
+ }
+
+ public override bool read_only {
+ get { return true; }
+ }
+
+ public override bool add (V key) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public override bool remove (V key) {
+ assert_not_reached ();
+ }
+
+ public override bool contains (V key) {
+ Iterator<V> it = iterator ();
+ while (it.next ()) {
+ if (_map.value_equal_func (key, it.get ())) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ private class SubValueCollection<K,V> : AbstractCollection<V> {
+ [CCode (notify = false)]
+ public TreeMap<K,V> map { private set; get; }
+ [CCode (notify = false)]
+ public Range<K,V> range { private set; get; }
+
+ public SubValueCollection (TreeMap<K,V> map, Range<K,V> range) {
+ this.map = map;
+ this.range = range;
+ }
+
+ public override Iterator<V> iterator () {
+ return new SubValueIterator<K,V> (map, range);
+ }
+
+ public override bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public override int size {
+ get {
+ var i = 0;
+ Vala.Iterator<V> iterator = iterator ();
+ while (iterator.next ())
+ i++;
+ return i;
+ }
+ }
+
+ public bool is_empty { get { return range.empty_submap (); } }
+
+ public override bool add (V key) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public override bool remove (V key) {
+ assert_not_reached ();
+ }
+
+ public override bool contains (V key) {
+ Iterator<V> it = iterator ();
+ while (it.next ()) {
+ if (map.value_equal_func (key, it.get ())) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ private class EntrySet<K,V> : AbstractBidirSortedSet<Map.Entry<K, V>> {
+ private TreeMap<K,V> _map;
+
+ public EntrySet (TreeMap<K,V> map) {
+ _map = map;
+ }
+
+ public override Iterator<Map.Entry<K, V>> iterator () {
+ return new EntryIterator<K,V> (_map);
+ }
+
+ public override int size {
+ get { return _map.size; }
+ }
+
+ public override bool read_only {
+ get { return true; }
+ }
+
+ public override bool add (Map.Entry<K, V> entry) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public override bool remove (Map.Entry<K, V> entry) {
+ assert_not_reached ();
+ }
+
+ public override bool contains (Map.Entry<K, V> entry) {
+ return _map.has (entry.key, entry.value);
+ }
+
+ public override Map.Entry<K, V>/*?*/ first () {
+ assert (_map.first != null);
+ return Entry.entry_for<K,V> (_map.first);
+ }
+
+ public override Map.Entry<K, V>/*?*/ last () {
+ assert (_map.last != null);
+ return Entry.entry_for<K,V> (_map.last);
+ }
+
+ public override BidirIterator<Map.Entry<K, V>> bidir_iterator () {
+ return new EntryIterator<K,V> (_map);
+ }
+
+ public override SortedSet<Map.Entry<K, V>> head_set (Map.Entry<K, V> before) {
+ return new SubEntrySet<K,V> (_map, new Range<K,V>.head (_map, before.key));
+ }
+
+ public override SortedSet<Map.Entry<K, V>> tail_set (Map.Entry<K, V> after) {
+ return new SubEntrySet<K,V> (_map, new Range<K,V>.tail (_map, after.key));
+ }
+
+ public override SortedSet<K> sub_set (Map.Entry<K, V> after, Map.Entry<K, V> before) {
+ return new SubEntrySet<K,V> (_map, new Range<K,V> (_map, after.key, before.key));
+ }
+
+ public override Iterator<Map.Entry<K, V>>? iterator_at (Map.Entry<K, V> item) {
+ weak Node<K,V>? node = _map.find_node (item.key);
+ if (node == null || !_map.value_equal_func (node.value, item.value))
+ return null;
+ return new EntryIterator<K,V>.pointing (_map, node);
+ }
+
+ public override Map.Entry<K, V>/*?*/ lower (Map.Entry<K, V> item) {
+ weak Node<K,V>? l = _map.find_lower (item.key);
+ return l != null ? Entry.entry_for<K,V> (l) : null;
+ }
+
+ public override Map.Entry<K, V>/*?*/ higher (Map.Entry<K, V> item) {
+ weak Node<K,V>? l = _map.find_higher (item.key);
+ return l != null ? Entry.entry_for<K,V> (l) : null;
+ }
+
+ public override Map.Entry<K, V>/*?*/ floor (Map.Entry<K, V> item) {
+ weak Node<K,V>? l = _map.find_floor (item.key);
+ return l != null ? Entry.entry_for<K,V> (l) : null;
+ }
+
+ public override Map.Entry<K, V>/*?*/ ceil (Map.Entry<K, V> item) {
+ weak Node<K,V>? l = _map.find_ceil (item.key);
+ return l != null ? Entry.entry_for<K,V> (l) : null;
+ }
+ }
+
+ private class SubEntrySet<K,V> : AbstractBidirSortedSet<Map.Entry<K,V>> {
+ [CCode (notify = false)]
+ public TreeMap<K,V> map { private set; get; }
+ [CCode (notify = false)]
+ public Range<K,V> range { private set; get; }
+
+ public SubEntrySet (TreeMap<K,V> map, Range<K,V> range) {
+ this.map = map;
+ this.range = range;
+ }
+
+ public override Iterator<Map.Entry<K,V>> iterator () {
+ return new SubEntryIterator<K,V> (map, range);
+ }
+
+ public override int size {
+ get {
+ var i = 0;
+ Vala.Iterator<Map.Entry<K,V>> iterator = iterator ();
+ while (iterator.next ())
+ i++;
+ return i;
+ }
+ }
+
+ public override bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public bool is_empty { get { return range.empty_submap (); } }
+
+ public override bool add (Map.Entry<K,V> entry) {
+ assert_not_reached ();
+ }
+
+ public override void clear () {
+ assert_not_reached ();
+ }
+
+ public override bool remove (Map.Entry<K,V> entry) {
+ assert_not_reached ();
+ }
+
+ public override bool contains (Map.Entry<K,V> entry) {
+ return range.in_range(entry.key) && map.has (entry.key, entry.value);
+ }
+
+ public override BidirIterator<K> bidir_iterator () {
+ return new SubEntryIterator<K,V> (map, range);
+ }
+
+ public override Map.Entry<K,V> first () {
+ weak Node<K,V>? _first = range.first ();
+ assert (_first != null);
+ return Entry.entry_for<K,V> (_first);
+ }
+
+ public override Map.Entry<K,V> last () {
+ weak Node<K,V>? _last = range.last ();
+ assert (_last != null);
+ return Entry.entry_for<K,V> (_last);
+ }
+
+ public override SortedSet<K> head_set (Map.Entry<K,V> before) {
+ return new SubEntrySet<K,V> (map, range.cut_tail (before.key));
+ }
+
+ public override SortedSet<K> tail_set (Map.Entry<K,V> after) {
+ return new SubEntrySet<K,V> (map, range.cut_head (after.key));
+ }
+
+ public override SortedSet<K> sub_set (Map.Entry<K,V> after, Map.Entry<K,V> before) {
+ return new SubEntrySet<K,V> (map, range.cut (after.key, before.key));
+ }
+
+ public override Iterator<Map.Entry<K,V>>? iterator_at (Map.Entry<K,V> entry) {
+ if (!range.in_range (entry.key))
+ return null;
+ weak Node<K,V>? n = map.find_node (entry.key);
+ if (n == null || !map.value_equal_func (n.value, entry.value))
+ return null;
+ return new SubEntryIterator<K,V>.pointing (map, range, n);
+ }
+
+ public override Map.Entry<K,V>/*?*/ lower (Map.Entry<K,V> entry) {
+ var res = range.compare_range (entry.key);
+ if (res > 0)
+ return last ();
+ weak Node<K,V>? l = map.find_lower (entry.key);
+ return l != null && range.in_range (l.key) ? Entry.entry_for<K,V> (l) : null;
+ }
+
+ public override Map.Entry<K,V>/*?*/ higher (Map.Entry<K,V> entry) {
+ var res = range.compare_range (entry.key);
+ if (res < 0)
+ return first ();
+ weak Node<K,V>? h = map.find_higher (entry.key);
+ return h != null && range.in_range (h.key) ? Entry.entry_for<K,V> (h) : null;
+ }
+
+ public override Map.Entry<K,V>/*?*/ floor (Map.Entry<K,V> entry) {
+ var res = range.compare_range (entry.key);
+ if (res > 0)
+ return last ();
+ weak Node<K,V>? l = map.find_floor (entry.key);
+ return l != null && range.in_range (l.key) ? Entry.entry_for<K,V> (l) : null;
+ }
+
+ public override Map.Entry<K,V>/*?*/ ceil (Map.Entry<K,V> entry) {
+ var res = range.compare_range (entry.key);
+ if (res < 0)
+ return first ();
+ weak Node<K,V>? h = map.find_ceil (entry.key);
+ return h != null && range.in_range (h.key) ? Entry.entry_for<K,V> (h) : null;
+ }
+ }
+
+ private class NodeIterator<K, V> : Object {
+ protected TreeMap<K,V> _map;
+
+ // concurrent modification protection
+ protected int stamp;
+
+ protected bool started = false;
+
+ internal weak Node<K, V>? current;
+ protected weak Node<K, V>? _next;
+ protected weak Node<K, V>? _prev;
+
+ public NodeIterator (TreeMap<K,V> map) {
+ _map = map;
+ this.stamp = _map.stamp;
+ }
+
+ public NodeIterator.pointing (TreeMap<K,V> map, Node<K,V> current) {
+ _map = map;
+ stamp = _map.stamp;
+ this.current = current;
+ }
+
+ public bool next () {
+ assert (stamp == _map.stamp);
+ if (current != null) {
+ if (current.next != null) {
+ current = current.next;
+ return true;
+ } else {
+ return false;
+ }
+ } else if (_next == null && _prev == null) {
+ current = _map.first;
+ started = true;
+ return current != null;
+ } else {
+ current = _next;
+ if (current != null) {
+ _next = null;
+ _prev = null;
+ }
+ return current != null;
+ }
+ }
+
+ public bool has_next () {
+ assert (stamp == _map.stamp);
+ return (current == null && _next == null && _prev == null && _map.first != null) ||
+ (current == null && _next != null) ||
+ (current != null && current.next != null);
+ }
+
+ public bool first () {
+ assert (stamp == _map.stamp);
+ current = _map.first;
+ _next = null;
+ _prev = null;
+ return current != null; // on false it is null anyway
+ }
+
+ public bool previous () {
+ assert (stamp == _map.stamp);
+ if (current != null) {
+ if (current.prev != null) {
+ current = current.prev;
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ if (_prev != null) {
+ current = _prev;
+ _next = null;
+ _prev = null;
+ return true;
+ } else {
+ return false;
+ }
+ }
+ }
+
+ public bool has_previous () {
+ assert (stamp == _map.stamp);
+ return (current == null && _prev != null) ||
+ (current != null && current.prev != null);
+ }
+
+ public bool last () {
+ assert (stamp == _map.stamp);
+ current = _map.last;
+ _next = null;
+ _prev = null;
+ return current != null; // on false it is null anyway
+ }
+
+ public void remove () {
+ assert_not_reached ();
+ }
+
+ public void unset () {
+ assert (stamp == _map.stamp);
+ assert (current != null);
+ V value;
+ bool success = _map.remove_from_node (ref _map.root, current.key, out value, out
_prev, out _next);
+ assert (success);
+ if (_map.root != null)
+ _map.root.color = Node.Color.BLACK;
+ current = null;
+ stamp++;
+ _map.stamp++;
+ assert (stamp == _map.stamp);
+ }
+
+ public virtual bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public bool valid {
+ get {
+ return current != null;
+ }
+ }
+
+ internal unowned Node<K,V>? safe_next_get () {
+ return (current != null) ? current.next : _next;
+ }
+
+ internal unowned Node<K,V>? safe_previous_get () {
+ return (current != null) ? current.prev : _prev;
+ }
+ }
+
+ private class SubNodeIterator<K,V> : Object {
+ public SubNodeIterator (TreeMap<K,V> map, Range<K,V> range) {
+ _map = map;
+ this.range = range;
+ }
+
+ public SubNodeIterator.pointing (TreeMap<K,V> map, Range<K,V> range, Node<K,V> node) {
+ _map = map;
+ this.range = range;
+ this.iterator = new NodeIterator<K,V>.pointing (_map, node);
+ }
+
+ public bool next () {
+ if (iterator != null) {
+ weak Node<K,V>? node= iterator.safe_next_get ();
+ if (node != null && range.in_range (node.key)) {
+ assert (iterator.next ());
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ return first ();
+ }
+ }
+
+ public bool has_next () {
+ if (iterator != null) {
+ weak Node<K,V>? node = iterator.safe_next_get ();
+ return node != null && range.in_range (node.key);
+ } else {
+ return range.first () != null;
+ }
+ }
+
+ public virtual bool first () {
+ weak Node<K,V>? node = range.first ();
+ if (node == null)
+ return false;
+ iterator = iterator_pointing_at (node);
+ return true;
+ }
+
+ public bool previous () {
+ if (iterator == null)
+ return false;
+ weak Node<K,V>? node;
+ if ((node = iterator.safe_previous_get ()) != null && range.in_range (node.key)) {
+ assert (iterator.previous ());
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public bool has_previous () {
+ if (iterator == null)
+ return false;
+ weak Node<K,V>? node;
+ return (node = iterator.safe_previous_get ()) != null && range.in_range (node.key);
+ }
+
+ public virtual bool last () {
+ weak Node<K,V>? node = range.last ();
+ if (node == null)
+ return false;
+ iterator = iterator_pointing_at (node);
+ return true;
+ }
+
+ public void remove () {
+ assert (valid);
+ iterator.remove ();
+ }
+
+ public void unset () {
+ assert (valid);
+ iterator.unset ();
+ }
+
+ public virtual bool read_only {
+ get {
+ return true;
+ }
+ }
+
+ public bool valid {
+ get {
+ return iterator != null && iterator.valid;
+ }
+ }
+
+ protected virtual NodeIterator<K,V> iterator_pointing_at (Node<K,V> node) {
+ return new NodeIterator<K,V>.pointing (_map, node);
+ }
+
+ protected new TreeMap<K,V> _map;
+ protected Range<K,V> range;
+ protected NodeIterator<K,V>? iterator = null;
+ }
+
+ private class KeyIterator<K,V> : NodeIterator<K, V>, Traversable<K>, Vala.Iterator<K>,
BidirIterator<K> {
+ public KeyIterator (TreeMap<K,V> map) {
+ base (map);
+ }
+
+ public KeyIterator.pointing (TreeMap<K,V> map, Node<K,V> current) {
+ base.pointing (map, current);
+ }
+
+ public new K get () {
+ assert (stamp == _map.stamp);
+ assert (current != null);
+ return current.key;
+ }
+
+ public bool foreach (ForallFunc<K> f) {
+ if (current != null) {
+ if (!f (current.key)) {
+ return false;
+ }
+ current = current.next;
+ } else if (_next == null) {
+ current = _map.first;
+ started = true;
+ } else {
+ current = _next;
+ if (current != null) {
+ _next = null;
+ _prev = null;
+ }
+ }
+ for (; current != null; current = current.next) {
+ if (!f (current.key)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ private class SubKeyIterator<K,V> : SubNodeIterator<K,V>, Traversable<K>, Vala.Iterator<K>,
BidirIterator<K> {
+ public SubKeyIterator (TreeMap<K,V> map, Range<K,V> range) {
+ base (map, range);
+ }
+
+ public SubKeyIterator.pointing (TreeMap<K,V> map, Range<K,V> range, Node<K,V> node) {
+ base.pointing (map, range, node);
+ }
+
+ public new K get () {
+ assert (valid);
+ return iterator.current.key;
+ }
+
+ public bool foreach (ForallFunc<K> f) {
+ if (valid) {
+ if (!f (iterator.current.key)) {
+ return false;
+ }
+ }
+ while (iterator.next ()) {
+ if (!f (iterator.current.key)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ private class ValueIterator<K,V> : NodeIterator<K,V>, Traversable<V>, Vala.Iterator<V>,
Vala.BidirIterator<V> {
+ public ValueIterator (TreeMap<K,V> map) {
+ base (map);
+ }
+
+ public ValueIterator.pointing (TreeMap<K,V> map, Node<K,V> current) {
+ base.pointing (map, current);
+ }
+
+ public new V get () {
+ assert (stamp == _map.stamp);
+ assert (valid);
+ return current.value;
+ }
+
+ public bool foreach (ForallFunc<V> f) {
+ if (current != null) {
+ if (!f (current.value)) {
+ return false;
+ }
+ current = current.next;
+ } else if (_next == null) {
+ current = _map.first;
+ started = true;
+ } else {
+ current = _next;
+ if (current != null) {
+ _next = null;
+ _prev = null;
+ }
+ }
+ for (; current != null; current = current.next) {
+ if (!f (current.value)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ private class SubValueIterator<K,V> : SubNodeIterator<K,V>, Traversable<V>, Vala.Iterator<V>,
BidirIterator<V> {
+ public SubValueIterator (TreeMap<K,V> map, Range<K,V> range) {
+ base (map, range);
+ }
+
+ public SubValueIterator.pointing (TreeMap<K,V> map, Range<K,V> range, Node<K,V> node) {
+ base.pointing (map, range, node);
+ }
+
+ public new V get () {
+ assert (valid);
+ return iterator.current.value;
+ }
+
+ public bool foreach (ForallFunc<V> f) {
+ if (valid) {
+ if (!f (iterator.current.key)) {
+ return false;
+ }
+ }
+ while (iterator.next ()) {
+ if (!f (iterator.current.key)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ private class EntryIterator<K,V> : NodeIterator<K,V>, Traversable<Map.Entry<K, V>>,
Vala.Iterator<Map.Entry<K,V>>, Vala.BidirIterator<Map.Entry<K,V>> {
+ public EntryIterator (TreeMap<K,V> map) {
+ base (map);
+ }
+
+ public EntryIterator.pointing (TreeMap<K,V> map, Node<K,V> node) {
+ base.pointing (map, node);
+ }
+
+ public new Map.Entry<K,V> get () {
+ assert (stamp == _map.stamp);
+ assert (valid);
+ return Entry.entry_for<K,V> (current);
+ }
+
+ public new void remove () {
+ unset ();
+ }
+
+ public bool foreach (ForallFunc<Map.Entry<K, V>> f) {
+ if (current != null) {
+ if (!f (Entry.entry_for<K,V> (current))) {
+ return false;
+ }
+ current = current.next;
+ } else if (_next == null) {
+ current = _map.first;
+ started = true;
+ } else {
+ current = _next;
+ if (current != null) {
+ _next = null;
+ _prev = null;
+ }
+ }
+ for (; current != null; current = current.next) {
+ if (!f (Entry.entry_for<K,V> (current))) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ private class SubEntryIterator<K,V> : SubNodeIterator<K,V>, Traversable<Map.Entry<K, V>>,
Vala.Iterator<Map.Entry<K,V>>, Vala.BidirIterator<Map.Entry<K,V>> {
+ public SubEntryIterator (TreeMap<K,V> map, Range<K,V> range) {
+ base (map, range);
+ }
+
+ public SubEntryIterator.pointing (TreeMap<K,V> map, Range<K,V> range, Node<K,V> node) {
+ base.pointing (map, range, node);
+ }
+
+ public new Map.Entry<K,V> get () {
+ assert (iterator != null);
+ return Entry.entry_for<K,V> (iterator.current);
+ }
+
+ public new void remove () {
+ unset ();
+ }
+
+ public bool foreach (ForallFunc<Map.Entry<K, V>> f) {
+ if (valid) {
+ if (!f (Entry.entry_for<K,V> (iterator.current))) {
+ return false;
+ }
+ }
+ while (iterator.next ()) {
+ if (!f (Entry.entry_for<K,V> (iterator.current))) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ private class MapIterator<K,V> : NodeIterator<K,V>, Vala.MapIterator<K,V>, BidirMapIterator<K,V> {
+ public MapIterator (TreeMap<K,V> map) {
+ base (map);
+ }
+
+ public K get_key () {
+ assert (stamp == _map.stamp);
+ assert (valid);
+ return current.key;
+ }
+
+ public V get_value () {
+ assert (stamp == _map.stamp);
+ assert (valid);
+ return current.value;
+ }
+
+ public void set_value (V value) {
+ assert (stamp == _map.stamp);
+ assert (valid);
+ current.value = value;
+ }
+
+ public override bool read_only {
+ get {
+ return false;
+ }
+ }
+
+ public bool mutable {
+ get {
+ return true;
+ }
+ }
+ }
+
+ private class SubMapIterator<K,V> : SubNodeIterator<K,V>, Vala.MapIterator<K,V>,
BidirMapIterator<K,V> {
+ public SubMapIterator (TreeMap<K,V> map, Range<K,V> range) {
+ base (map, range);
+ }
+
+ public K get_key () {
+ assert (valid);
+ return iterator.current.key;
+ }
+
+ public V get_value () {
+ assert (valid);
+ return iterator.current.value;
+ }
+
+ public void set_value (V value) {
+ assert (valid);
+ iterator.current.value = value;
+ }
+
+ public override bool read_only {
+ get {
+ return false;
+ }
+ }
+
+ public bool mutable {
+ get {
+ return true;
+ }
+ }
+ }
+}
diff --git a/gee/treemultimap.vala b/gee/treemultimap.vala
new file mode 100644
index 0000000..452dd97
--- /dev/null
+++ b/gee/treemultimap.vala
@@ -0,0 +1,63 @@
+/* treemultimap.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Left-leaning red-black tree implementation of the {@link MultiMap}
+ * interface.
+ */
+public class Vala.TreeMultiMap<K,V> : AbstractMultiMap<K,V> {
+ public CompareDataFunc<K> key_compare_func {
+ get { return ((TreeMap<K, Set<V>>) _storage_map).key_compare_func; }
+ }
+
+ [CCode (notify = false)]
+ public CompareDataFunc<V> value_compare_func { private set; get; }
+
+ /**
+ * Constructs a new, empty tree multimap.
+ *
+ * If not provided, the functions parameters are requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param key_compare_func an optional key comparator function
+ * @param value_compare_func an optional value comparator function
+ */
+ public TreeMultiMap (owned CompareDataFunc<K>? key_compare_func = null, owned CompareDataFunc<V>?
value_compare_func = null) {
+ base (new TreeMap<K, Set<V>> (key_compare_func, Functions.get_equal_func_for (typeof (Set))));
+ if (value_compare_func == null) {
+ value_compare_func = Functions.get_compare_func_for (typeof (V));
+ }
+ this.value_compare_func = value_compare_func;
+ }
+
+ protected override Collection<V> create_value_storage () {
+ return new TreeSet<V> (_value_compare_func);
+ }
+
+ protected override MultiSet<K> create_multi_key_set () {
+ return new TreeMultiSet<K> (key_compare_func);
+ }
+
+ protected override EqualDataFunc<V> get_value_equal_func () {
+ return Functions.get_equal_func_for (typeof (V));
+ }
+}
diff --git a/gee/treemultiset.vala b/gee/treemultiset.vala
new file mode 100644
index 0000000..992d96d
--- /dev/null
+++ b/gee/treemultiset.vala
@@ -0,0 +1,43 @@
+/* treemultiset.vala
+ *
+ * Copyright (C) 2009 Didier Villevalois
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Didier 'Ptitjes Villevalois <ptitjes free fr>
+ */
+
+/**
+ * Left-leaning red-black tree implementation of the {@link MultiSet}
+ * interface.
+ */
+public class Vala.TreeMultiSet<G> : AbstractMultiSet<G> {
+ public CompareDataFunc<G> compare_func {
+ get { return ((TreeMap<G, int>) _storage_map).key_compare_func; }
+ }
+
+ /**
+ * Constructs a new, empty tree multi set.
+ *
+ * If not provided, the function parameter is requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param compare_func an optional element comparator function
+ */
+ public TreeMultiSet (owned CompareDataFunc<G>? compare_func = null) {
+ base (new TreeMap<G, int> (compare_func));
+ }
+}
diff --git a/gee/treeset.vala b/gee/treeset.vala
new file mode 100644
index 0000000..0ea02aa
--- /dev/null
+++ b/gee/treeset.vala
@@ -0,0 +1,1162 @@
+/* treeset.vala
+ *
+ * Copyright (C) 2009-2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+using GLib;
+
+/**
+ * Left-leaning red-black tree implementation of the {@link Set} interface.
+ *
+ * This implementation is especially well designed for large quantity of
+ * data. The (balanced) tree implementation insure that the set and get
+ * methods are in logarithmic complexity. For a linear implementation see
+ * {@link HashSet}.
+ *
+ * @see HashSet
+ */
+public class Vala.TreeSet<G> : AbstractBidirSortedSet<G> {
+ /**
+ * {@inheritDoc}
+ */
+ public override int size {
+ get {return _size;}
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool read_only {
+ get { return false; }
+ }
+
+ /**
+ * The elements' comparator function.
+ */
+ [CCode (notify = false)]
+ public CompareDataFunc<G> compare_func { private set; get; }
+
+ private int _size = 0;
+
+ /**
+ * Constructs a new, empty tree set sorted according to the specified
+ * comparator function.
+ *
+ * If not provided, the function parameter is requested to the
+ * {@link Functions} function factory methods.
+ *
+ * @param compare_func an optional element comparator function
+ */
+ public TreeSet (owned CompareDataFunc<G>? compare_func = null) {
+ if (compare_func == null) {
+ compare_func = Functions.get_compare_func_for (typeof (G));
+ }
+ this.compare_func = compare_func;
+ }
+
+ ~TreeSet () {
+ clear ();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool contains (G item) {
+ weak Node<G>? cur = root;
+ while (cur != null) {
+ int res = compare_func (item, cur.key);
+ if (res == 0) {
+ return true;
+ } else if (res < 0) {
+ cur = cur.left;
+ } else {
+ cur = cur.right;
+ }
+ }
+ return false;
+ }
+
+ private inline void rotate_right (ref Node<G> root) {
+ Node<G> pivot = (owned) root.left;
+ pivot.color = root.color;
+ root.color = Node.Color.RED;
+ root.left = (owned) pivot.right;
+ pivot.right = (owned) root;
+ root = (owned) pivot;
+#if DEBUG
+ stdout.printf (dump ("after rotate right on %s".printf ((string)root.right.key)));
+#endif
+ }
+
+ private inline void rotate_left (ref Node<G> root) {
+ Node<G> pivot = (owned) root.right;
+ pivot.color = root.color;
+ root.color = Node.Color.RED;
+ root.right = (owned) pivot.left;
+ pivot.left = (owned) root;
+ root = (owned) pivot;
+#if DEBUG
+ stdout.printf (dump ("after rotate left on %s".printf ((string)root.left.key)));
+#endif
+ }
+
+ private inline bool is_red (Node<G>? n) {
+ return n != null && n.color == Node.Color.RED;
+ }
+
+ private inline bool is_black (Node<G>? n) {
+ return n == null || n.color == Node.Color.BLACK;
+ }
+
+ private inline void fix_up (ref Node<G> node) {
+#if DEBUG
+ var n = (string)node.key;
+#endif
+ if (is_black (node.left) && is_red (node.right)) {
+ rotate_left (ref node);
+ }
+ if (is_red (node.left) && is_red (node.left.left)) {
+ rotate_right (ref node);
+ }
+ if (is_red (node.left) && is_red (node.right)) {
+ node.flip ();
+ }
+#if DEBUG
+ stdout.printf (dump ("after fix up on %s".printf (n)));
+#endif
+ }
+
+ private bool add_to_node (ref Node<G>? node, owned G item, Node<G>? prev, Node<G>? next) {
+#if DEBUG
+ if (node != null)
+ stdout.printf ("Adding %s to %s\n".printf ((string) item, (string) node.key));
+#endif
+ if (node == null) {
+ node = new Node<G> ((owned) item, prev, next);
+ if (prev == null) {
+ _first = node;
+ }
+ if (next == null) {
+ _last = node;
+ }
+ _size++;
+ return true;
+ }
+
+ int cmp = compare_func (item, node.key);
+ if (cmp == 0) {
+ fix_up (ref node);
+ return false;
+ } else if (cmp < 0) {
+ bool r = add_to_node (ref node.left, item, node.prev, node);
+ fix_up (ref node);
+ return r;
+ } else {
+ bool r = add_to_node (ref node.right, item, node, node.next);
+ fix_up (ref node);
+ return r;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * If the element already exists in the set it will not be added twice.
+ */
+ public override bool add (G item) {
+#if CONSISTENCY_CHECKS
+ check ();
+#endif
+ bool r = add_to_node (ref root, item, null, null);
+ root.color = Node.Color.BLACK;
+#if CONSISTENCY_CHECKS
+ check ();
+#endif
+ stamp++;
+ return r;
+ }
+
+ private inline void move_red_left (ref Node<G> root) {
+#if DEBUG
+ var n = (string)root.key;
+#endif
+ root.flip ();
+ if (is_red (root.right.left)) {
+ rotate_right (ref root.right);
+ rotate_left (ref root);
+ root.flip ();
+ }
+#if DEBUG
+ stdout.printf (dump ("after red left on %s".printf (n)));
+#endif
+ }
+
+ private inline void move_red_right (ref Node<G> root) {
+#if DEBUG
+ var n = (string)root.key;
+#endif
+ root.flip ();
+ if (is_red (root.left.left)) {
+ rotate_right (ref root);
+ root.flip ();
+ }
+#if DEBUG
+ stdout.printf (dump ("after red right on %s".printf (n)));
+#endif
+ }
+
+ private inline void fix_removal (ref Node<G> node, out G? key = null) {
+ Node<G> n = (owned)node;
+ key = (owned) n.key;
+ if (n.prev != null) {
+ n.prev.next = n.next;
+ } else {
+ _first = n.next;
+ }
+ if (n.next != null) {
+ n.next.prev = n.prev;
+ } else {
+ _last = n.prev;
+ }
+ node = null;
+ _size--;
+ }
+
+ private void remove_minimal (ref Node<G> node, out G key) {
+ if (node.left == null) {
+ fix_removal (ref node, out key);
+ return;
+ }
+
+ if (is_black (node.left) && is_black (node.left.left)) {
+ move_red_left (ref node);
+ }
+
+ remove_minimal (ref node.left, out key);
+
+ fix_up (ref node);
+ }
+
+ private bool remove_from_node (ref Node<G>? node, G item, out unowned Node<G>? prev = null, out
unowned Node<G>? next = null) {
+#if DEBUG
+ stdout.printf ("Removing %s from %s\n", (string)item, node != null ? (string)node.key : null);
+#endif
+ if (node == null) {
+ prev = null;
+ next = null;
+ return false;
+ } else if (compare_func (item, node.key) < 0) {
+ weak Node<G> left = node.left;
+ if (left == null) {
+ prev = null;
+ next = null;
+ return false;
+ }
+ if (is_black (left) && is_black (left.left)) {
+ move_red_left (ref node);
+ }
+ bool r = remove_from_node (ref node.left, item, out prev, out next);
+ fix_up (ref node);
+ return r;
+ } else {
+ if (is_red (node.left)) {
+ rotate_right (ref node);
+ }
+
+ weak Node<G>? r = node.right;
+ if (compare_func (item, node.key) == 0 && r == null) {
+ prev = node.prev;
+ next = node.next;
+ fix_removal (ref node, null);
+ return true;
+ }
+ if (is_black (r) && r != null && is_black (r.left)) {
+ move_red_right (ref node);
+ }
+ if (compare_func (item, node.key) == 0) {
+ prev = node.prev;
+ next = node;
+ remove_minimal (ref node.right, out node.key);
+ fix_up (ref node);
+ return true;
+ } else {
+ bool re = remove_from_node (ref node.right, item, out prev, out next);
+ fix_up (ref node);
+ return re;
+ }
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override bool remove (G item) {
+#if CONSISTENCY_CHECKS
+ check ();
+#endif
+ bool b = remove_from_node (ref root, item);
+ if (root != null) {
+ root.color = Node.Color.BLACK;
+ }
+#if CONSISTENCY_CHECKS
+ check ();
+#endif
+ stamp++;
+ return b;
+ }
+
+ private inline void clear_subtree (owned Node<G> node) {
+ node.key = null;
+ if (node.left != null)
+ clear_subtree ((owned) node.left);
+ if (node.right != null)
+ clear_subtree ((owned) node.right);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override void clear () {
+ if (root != null) {
+ clear_subtree ((owned) root);
+ _first = _last = null;
+ }
+ _size = 0;
+ stamp++;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.Iterator<G> iterator () {
+ return new Iterator<G> (this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override BidirIterator<G> bidir_iterator () {
+ return new Iterator<G> (this);
+ }
+
+ private inline G? lift_null_get (Node<G>? node) {
+ return node != null ? node.key : null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G first () {
+ assert (_first != null);
+ return _first.key;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G last () {
+ assert (_last != null);
+ return _last.key;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override SortedSet<G> head_set (G before) {
+ return new SubSet<G>.head (this, before);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override SortedSet<G> tail_set (G after) {
+ return new SubSet<G>.tail (this, after);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override SortedSet<G> sub_set (G after, G before) {
+ return new SubSet<G> (this, after, before);
+ }
+
+ private inline unowned Node<G>? find_node (G item) {
+ weak Node<G>? cur = root;
+ while (cur != null) {
+ int res = compare_func (item, cur.key);
+ if (res == 0) {
+ return cur;
+ } else if (res < 0) {
+ cur = cur.left;
+ } else {
+ cur = cur.right;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override Vala.Iterator<G>? iterator_at (G item) {
+ weak Node<G>? node = find_node (item);
+ return node != null ? new Iterator<G>.pointing (this, node) : null;
+ }
+
+ private inline unowned Node<G>? find_nearest (G item) {
+ weak Node<G>? cur = root;
+ while (cur != null) {
+ int res = compare_func (item, cur.key);
+ if (res == 0) {
+ return cur;
+ } else if (res < 0) {
+ if (cur.left == null)
+ return cur;
+ cur = cur.left;
+ } else {
+ if (cur.right == null)
+ return cur;
+ cur = cur.right;
+ }
+ }
+ return null;
+ }
+
+ private inline unowned Node<G>? find_lower (G item) {
+ weak Node<G>? node = find_nearest (item);
+ if (node == null)
+ return null;
+ return compare_func (item, node.key) <= 0 ? node.prev : node;
+ }
+
+ private inline unowned Node<G>? find_higher (G item) {
+ weak Node<G>? node = find_nearest (item);
+ if (node == null)
+ return null;
+ return compare_func (item, node.key) >= 0 ? node.next : node;
+ }
+
+ private inline unowned Node<G>? find_floor (G item) {
+ weak Node<G>? node = find_nearest (item);
+ if (node == null)
+ return null;
+ return compare_func (item, node.key) < 0 ? node.prev : node;
+ }
+
+ private inline unowned Node<G>? find_ceil (G item) {
+ weak Node<G>? node = find_nearest (item);
+ if (node == null)
+ return null;
+ return compare_func (item, node.key) > 0 ? node.next : node;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? lower (G item) {
+ return lift_null_get (find_lower (item));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? higher (G item) {
+ return lift_null_get (find_higher (item));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? floor (G item) {
+ return lift_null_get (find_floor (item));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public override G? ceil (G item) {
+ return lift_null_get (find_ceil (item));
+ }
+
+#if CONSISTENCY_CHECKS
+ public inline void check () {
+ check_subtree (root);
+ assert (root == null || root.color == Node.Color.BLACK);
+#if DEBUG
+ stdout.printf ("%s\n", dump ());
+#endif
+ }
+
+ private inline uint check_subtree (Node<G>? node) {
+ if (node == null)
+ return 0;
+ assert (! (is_black (node.left) && is_red (node.right))); // Check left-leaning
+ assert (! (is_red (node) && is_red (node.left))); // Check red property
+ uint l = check_subtree (node.left);
+ uint r = check_subtree (node.right);
+ assert (l == r);
+ return l + (node.color == Node.Color.BLACK ? 1 : 0);
+ }
+#endif
+#if DEBUG
+ public string dump (string? when = null) {
+ return "TreeSet dump%s:\n%s".printf (when == null ? "" : (" " + when), dump_node (root));
+ }
+
+ private inline string dump_node (Node<G>? node, uint depth = 0) {
+ if (node != null)
+ return dump_node (node.left, depth + 1) +
+ "%s%s%p(%s)\033[0m\n".printf (string.nfill (depth, ' '),
+ node.color == Node.Color.RED ? "\033[0;31m" : "",
+ node, (string)node.key) +
+ dump_node (node.right, depth + 1);
+ return "";
+ }
+#endif
+
+ [Compact]
+ private class Node<G> {
+ public enum Color {
+ RED,
+ BLACK;
+
+ public Color flip () {
+ if (this == RED) {
+ return BLACK;
+ } else {
+ return RED;
+ }
+ }
+ }
+
+ public Node (owned G node, Node<G>? prev, Node<G>? next) {
+ this.key = (owned) node;
+ this.color = Color.RED;
+ this.prev = prev;
+ this.next = next;
+ if (prev != null) {
+ prev.next = this;
+ }
+ if (next != null) {
+ next.prev = this;
+ }
+ }
+
+ public void flip () {
+ color = color.flip ();
+ if (left != null) {
+ left.color = left.color.flip ();
+ }
+ if (right != null) {
+ right.color = right.color.flip ();
+ }
+ }
+
+ public G key;
+ public Color color;
+ public Node<G>? left;
+ public Node<G>? right;
+ public weak Node<G>? prev;
+ public weak Node<G>? next;
+ }
+
+ private class Iterator<G> : Object, Traversable<G>, Vala.Iterator<G>, BidirIterator<G> {
+ private TreeSet<G> _set;
+
+ // concurrent modification protection
+ private int stamp;
+
+ public Iterator (TreeSet<G> set) {
+ _set = set;
+ stamp = _set.stamp;
+ }
+
+ public Iterator.pointing (TreeSet<G> set, Node<G> current) {
+ this._set = set;
+ this._current = current;
+ this.stamp = set.stamp;
+ this.started = true;
+ }
+
+ public bool next () {
+ assert (stamp == _set.stamp);
+ if (_current != null) {
+ if (_current.next != null) {
+ _current = _current.next;
+ return true;
+ } else {
+ return false;
+ }
+ } else if (!started) {
+ _current = _set._first;
+ started = true;
+ return _current != null;
+ } else {
+ _current = _next;
+ if (_current != null) {
+ _next = null;
+ _prev = null;
+ }
+ return _current != null;
+ }
+ }
+
+ public bool has_next () {
+ assert (stamp == _set.stamp);
+ return (!started && _set._first != null) ||
+ (_current == null && _next != null) ||
+ (_current != null && _current.next != null);
+ }
+
+ public bool first () {
+ assert (stamp == _set.stamp);
+ _current = _set._first;
+ _next = null;
+ _prev = null;
+ started = true;
+ return _current != null; // on false it is null anyway
+ }
+
+ public bool previous () {
+ assert (stamp == _set.stamp);
+ if (_current != null) {
+ if (_current.prev != null) {
+ _current = _current.prev;
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ if (_prev != null) {
+ _current = _prev;
+ _next = null;
+ _prev = null;
+ return true;
+ } else {
+ return false;
+ }
+ }
+ }
+
+ public bool has_previous () {
+ assert (stamp == _set.stamp);
+ return (_current == null && _prev != null) ||
+ (_current != null && _current.prev != null);
+ }
+
+ public bool last () {
+ assert (stamp == _set.stamp);
+ _current = _set._last;
+ _next = null;
+ _prev = null;
+ started = true;
+ return _current != null; // on false it is null anyway
+ }
+
+ public new G get () {
+ assert (stamp == _set.stamp);
+ assert (_current != null);
+ return _current.key;
+ }
+
+ public void remove () {
+ assert (stamp == _set.stamp);
+ assert (_current != null);
+ bool success = _set.remove_from_node (ref _set.root, _current.key, out _prev, out
_next);
+ assert (success);
+ if (_set.root != null)
+ _set.root.color = Node.Color.BLACK;
+ _current = null;
+ assert (stamp++ == _set.stamp++);
+ }
+
+ internal bool safe_next_get (out G val) {
+ if (_current != null) {
+ val = _set.lift_null_get (_current.next);
+ return _current.next != null;
+ } else {
+ val = _set.lift_null_get (_next);
+ return _next != null;
+ }
+ }
+
+ internal bool safe_previous_get (out G val) {
+ if (_current != null) {
+ val = _set.lift_null_get (_current.prev);
+ return _current.prev != null;
+ } else {
+ val = _set.lift_null_get (_prev);
+ return _next != null;
+ }
+ }
+
+ public bool valid {
+ get {
+ assert (stamp == _set.stamp);
+ return _current != null;
+ }
+ }
+
+ public bool read_only {
+ get {
+ return false;
+ }
+ }
+
+ public bool foreach (ForallFunc<G> f) {
+ assert (stamp == _set.stamp);
+ unowned Node<G>? current = _current, next;
+ if (current != null) {
+ if (!f (current.key)) {
+ return false;
+ }
+ next = current.next;
+ } else if (!started) {
+ next = _set._first;
+ if (next != null) {
+ started = true;
+ }
+ } else {
+ next = _next;
+ if (next != null) {
+ _next = null;
+ _prev = null;
+ }
+ }
+ while (next != null) {
+ if (!f (next.key)) {
+ _current = next;
+ return false;
+ }
+ current = next;
+ next = current.next;
+ }
+ _current = current;
+ return true;
+ }
+
+ private weak Node<G>? _current = null;
+ private weak Node<G>? _next = null;
+ private weak Node<G>? _prev = null;
+ private bool started = false;
+ }
+
+ private inline G min (G a, G b) {
+ return compare_func (a, b) <= 0 ? a : b;
+ }
+
+ private inline G max (G a, G b) {
+ return compare_func (a, b) > 0 ? a : b;
+ }
+
+ private class Range<G> {
+ public Range (TreeSet<G> set, G after, G before) {
+ this.set = set;
+ if (set.compare_func (after, before) < 0) {
+ this.after = after;
+ this.before = before;
+ type = RangeType.BOUNDED;
+ } else {
+ type = RangeType.EMPTY;
+ }
+ }
+
+ public Range.head (TreeSet<G> set, G before) {
+ this.set = set;
+ this.before = before;
+ type = RangeType.HEAD;
+ }
+
+ public Range.tail (TreeSet<G> set, G after) {
+ this.set = set;
+ this.after = after;
+ type = RangeType.TAIL;
+ }
+
+#if false
+ public Range.empty (TreeSet<G> set) {
+ this.set = set;
+ type = RangeType.EMPTY;
+ }
+#endif
+
+ public Range<G> cut_head (G after) {
+ switch (type) {
+ case RangeType.HEAD:
+ return new Range<G> (set, after, before);
+ case RangeType.TAIL:
+ return new Range<G>.tail (set, set.max (after, this.after));
+ case RangeType.EMPTY:
+ return this;
+ case RangeType.BOUNDED:
+ var _after = set.max (after, this.after);
+ return new Range<G> (set, _after, before);
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ public Range<G> cut_tail (G before) {
+ switch (type) {
+ case RangeType.HEAD:
+ return new Range<G>.head (set, set.min (before, this.before));
+ case RangeType.TAIL:
+ return new Range<G> (set, after, before);
+ case RangeType.EMPTY:
+ return this;
+ case RangeType.BOUNDED:
+ var _before = set.min (before, this.before);
+ return new Range<G> (set, after, _before);
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ public Range<G> cut (G after, G before) {
+ if (type == RangeType.EMPTY)
+ return this;
+ var _before = type != RangeType.TAIL ? set.min (before, this.before) : before;
+ var _after = type != RangeType.HEAD ? set.max (after, this.after) : after;
+ return new Range<G> (set, _after, _before);
+ }
+
+ public bool in_range (G item) {
+ return type == RangeType.EMPTY ? false : compare_range (item) == 0;
+ }
+
+ public int compare_range (G item) {
+ switch (type) {
+ case RangeType.HEAD:
+ return set.compare_func (item, before) < 0 ? 0 : 1;
+ case RangeType.TAIL:
+ return set.compare_func (item, after) >= 0 ? 0 : -1;
+ case RangeType.EMPTY:
+ return 0; // For simplicity - please make sure it does not break anything
+ case RangeType.BOUNDED:
+ return set.compare_func (item, after) >= 0 ?
+ (set.compare_func (item, before) < 0 ? 0 : 1) : -1;
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ public bool empty_subset () {
+ switch (type) {
+ case RangeType.HEAD:
+ return set._first == null || !in_range (set._first.key);
+ case RangeType.TAIL:
+ return set._last == null || !in_range (set._last.key);
+ case RangeType.EMPTY:
+ return true;
+ case RangeType.BOUNDED:
+ return first () == null;
+ default:
+ assert_not_reached ();
+ }
+ }
+
+ public unowned Node<G>? first () {
+ switch (type) {
+ case RangeType.EMPTY:
+ return null;
+ case RangeType.HEAD:
+ return set._first;
+ default:
+ return set.find_floor (after);
+ }
+ }
+
+ public unowned Node<G>? last () {
+ switch (type) {
+ case RangeType.EMPTY:
+ return null;
+ case RangeType.TAIL:
+ return set._last;
+ default:
+ return set.find_lower (before);
+ }
+ }
+
+ private new TreeSet<G> set;
+ private G after;
+ private G before;
+ private RangeType type;
+ }
+
+ private enum RangeType {
+ HEAD,
+ TAIL,
+ EMPTY,
+ BOUNDED
+ }
+
+ private class SubSet<G> : AbstractBidirSortedSet<G> {
+ public SubSet (TreeSet<G> set, G after, G before) {
+ this.set = set;
+ this.range = new Range<G> (set, after, before);
+ }
+
+ public SubSet.head (TreeSet<G> set, G before) {
+ this.set = set;
+ this.range = new Range<G>.head (set, before);
+ }
+
+ public SubSet.tail (TreeSet<G> set, G after) {
+ this.set = set;
+ this.range = new Range<G>.tail (set, after);
+ }
+
+ public SubSet.from_range (TreeSet<G> set, Range<G> range) {
+ this.set = set;
+ this.range = range;
+ }
+
+ public override int size {
+ get {
+ var i = 0;
+ Vala.Iterator<G> iterator = iterator ();
+ while (iterator.next ())
+ i++;
+ return i;
+ }
+ }
+
+ public override bool read_only {
+ get { return true; }
+ }
+
+ public bool is_empty {
+ get {
+ return range.empty_subset ();
+ }
+ }
+
+ public override bool contains (G item) {
+ return range.in_range (item) && set.contains (item);
+ }
+
+ public override bool add (G item) {
+ return range.in_range (item) && set.add (item);
+ }
+
+ public override bool remove (G item) {
+ return range.in_range (item) && set.remove (item);
+ }
+
+ public override void clear () {
+ var iter = iterator ();
+ while (iter.next ()) {
+ iter.remove ();
+ }
+ }
+
+ public override Vala.Iterator<G> iterator () {
+ return new SubIterator<G> (set, range);
+ }
+
+ public override BidirIterator<G> bidir_iterator () {
+ return new SubIterator<G> (set, range);
+ }
+
+ public override G first () {
+ weak Node<G>? _first = range.first ();
+ assert (_first != null);
+ return _first.key;
+ }
+
+ public override G last () {
+ weak Node<G>? _last = range.last ();
+ assert (_last != null);
+ return _last.key;
+ }
+
+ public override SortedSet<G> head_set (G before) {
+ return new SubSet<G>.from_range (set, range.cut_tail (before));
+ }
+
+ public override SortedSet<G> tail_set (G after) {
+ return new SubSet<G>.from_range (set, range.cut_head (after));
+ }
+
+ public override SortedSet<G> sub_set (G after, G before) {
+ return new SubSet<G>.from_range (set, range.cut (after, before));
+ }
+
+ public override Vala.Iterator<G>? iterator_at (G item) {
+ if (!range.in_range (item))
+ return null;
+ weak Node<G>? n = set.find_node (item);
+ if (n == null)
+ return null;
+ return new SubIterator<G>.pointing (set, range, n);
+ }
+
+ public override G? lower (G item) {
+ var res = range.compare_range (item);
+ if (res > 0)
+ return last ();
+ var l = set.lower (item);
+ return l != null && range.in_range (l) ? l : null;
+ }
+
+ public override G? higher (G item) {
+ var res = range.compare_range (item);
+ if (res < 0)
+ return first ();
+ var h = set.higher (item);
+ return h != null && range.in_range (h) ? h : null;
+ }
+
+ public override G? floor (G item) {
+ var res = range.compare_range (item);
+ if (res > 0)
+ return last ();
+ var l = set.floor (item);
+ return l != null && range.in_range (l) ? l : null;
+ }
+
+ public override G? ceil (G item) {
+ var res = range.compare_range (item);
+ if (res < 0)
+ return first ();
+ var h = set.ceil (item);
+ return h != null && range.in_range (h) ? h : null;
+ }
+
+ private new TreeSet<G> set;
+ private Range<G> range;
+ }
+
+ private class SubIterator<G> : Object, Traversable<G>, Vala.Iterator<G>, BidirIterator<G> {
+ public SubIterator (TreeSet<G> set, Range<G> range) {
+ this.set = set;
+ this.range = range;
+ }
+
+ public SubIterator.pointing (TreeSet<G> set, Range<G> range, Node<G> node) {
+ this.set = set;
+ this.range = range;
+ this.iterator = new Iterator<G>.pointing (set, node);
+ }
+
+ public bool next () {
+ if (iterator != null) {
+ G next;
+ if (iterator.safe_next_get (out next) && range.in_range (next)) {
+ assert (iterator.next ());
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ return first ();
+ }
+ }
+
+ public bool has_next () {
+ if (iterator != null) {
+ G next;
+ return (iterator.safe_next_get (out next) && range.in_range (next));
+ } else {
+ return range.first () != null;
+ }
+ }
+
+ public bool first () {
+ weak Node<G>? node = range.first ();
+ if (node == null)
+ return false;
+ iterator = new Iterator<G>.pointing (set, node);
+ return true;
+ }
+
+ public bool previous () {
+ if (iterator == null)
+ return false;
+ G prev;
+ if (iterator.safe_previous_get (out prev) && range.in_range (prev)) {
+ assert (iterator.previous ());
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public bool has_previous () {
+ if (iterator == null)
+ return false;
+ G prev;
+ return iterator.safe_previous_get (out prev) && range.in_range (prev);
+ }
+
+ public bool last () {
+ weak Node<G>? node = range.last ();
+ if (node == null)
+ return false;
+ iterator = new Iterator<G>.pointing (set, node);
+ return true;
+ }
+
+ public new G get () {
+ assert (iterator != null);
+ return iterator.get ();
+ }
+
+ public void remove () {
+ assert (iterator != null);
+ iterator.remove ();
+ }
+
+ public bool read_only {
+ get {
+ return false;
+ }
+ }
+
+ public bool valid {
+ get {
+ return iterator.valid;
+ }
+ }
+
+ public bool foreach(ForallFunc<G> f) {
+ if(valid) {
+ if (!f(get())) {
+ return false;
+ }
+ }
+ while(next()) {
+ if (!f(get())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private new TreeSet<G> set;
+ private Range<G> range;
+ private Iterator<G>? iterator = null;
+ }
+
+ private Node<G>? root = null;
+ private weak Node<G>? _first = null;
+ private weak Node<G>? _last = null;
+ private int stamp = 0;
+}
diff --git a/gee/unfolditerator.vala b/gee/unfolditerator.vala
new file mode 100644
index 0000000..b513f05
--- /dev/null
+++ b/gee/unfolditerator.vala
@@ -0,0 +1,102 @@
+/* unfolditerator.vala
+ *
+ * Copyright (C) 2011 Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+internal class Vala.UnfoldIterator<G> : Object, Traversable<G>, Iterator<G> {
+ public UnfoldIterator (owned UnfoldFunc<G> func, owned Lazy<G>? current = null) {
+ _current = (owned)current;
+ _func = (owned)func;
+ _end = false;
+ }
+
+ public bool next () {
+ if (has_next ()) {
+ if (_current != null)
+ _current.eval ();
+ _current = (owned)_next;
+ return true;
+ }
+ return false;
+ }
+
+ public bool has_next () {
+ if (_end)
+ return false;
+ if (_next != null)
+ return true;
+ _next = _func ();
+ if (_next == null)
+ _end = true;
+ return _next != null;
+ }
+
+ public new G get () {
+ assert (_current != null);
+ return _current.value;
+ }
+
+ public void remove () {
+ assert_not_reached ();
+ }
+
+ public bool valid { get { return _current != null; } }
+ public bool read_only { get { return true; } }
+
+ public bool foreach (ForallFunc<G> f) {
+ if (_current != null) {
+ if (!f (_current.value)) {
+ return false;
+ }
+ }
+ if (_next != null) {
+ _current = (owned)_next;
+ if (!f (_current.value)) {
+ return false;
+ }
+ } else if (_end) {
+ return true;
+ }
+ if (_current == null) {
+ _current = _func ();
+ if (_current == null) {
+ _end = true;
+ return true;
+ } else {
+ if (!f (_current.value)) {
+ return false;
+ }
+ }
+ }
+ while ((_next = _func ()) != null) {
+ _current = (owned)_next;
+ if (!f (_current.value)) {
+ return false;
+ }
+ }
+ _end = true;
+ return true;
+ }
+
+ private UnfoldFunc<G> _func;
+ private Lazy<G>? _current;
+ private Lazy<G>? _next;
+ private bool _end;
+}
diff --git a/vala/valaattribute.vala b/vala/valaattribute.vala
index f1ef73f..889517c 100644
--- a/vala/valaattribute.vala
+++ b/vala/valaattribute.vala
@@ -34,7 +34,7 @@ public class Vala.Attribute : CodeNode {
/**
* Contains all specified attribute arguments.
*/
- public Vala.Map<string,string> args = new HashMap<string,string> (str_hash, str_equal);
+ public Map<string,string> args = new HashMap<string,string> ();
/**
* Creates a new attribute.
@@ -73,7 +73,7 @@ public class Vala.Attribute : CodeNode {
* @return true if the argument has been found, false otherwise
*/
public bool has_argument (string name) {
- return args.contains (name);
+ return args.has_key (name);
}
/**
diff --git a/vala/valacodecontext.vala b/vala/valacodecontext.vala
index ddb9fdf..1f68a84 100644
--- a/vala/valacodecontext.vala
+++ b/vala/valacodecontext.vala
@@ -209,9 +209,9 @@ public class Vala.CodeContext {
private List<string> c_source_files = new ArrayList<string> ();
private Namespace _root = new Namespace (null);
- private List<string> packages = new ArrayList<string> (str_equal);
+ private List<string> packages = new ArrayList<string> ();
- private Set<string> defines = new HashSet<string> (str_hash, str_equal);
+ private Set<string> defines = new HashSet<string> ();
static StaticPrivate context_stack_key = StaticPrivate ();
diff --git a/vala/valacodenode.vala b/vala/valacodenode.vala
index 5413ed4..319b761 100644
--- a/vala/valacodenode.vala
+++ b/vala/valacodenode.vala
@@ -192,7 +192,7 @@ public abstract class Vala.CodeNode {
public void remove_attribute_argument (string attribute, string argument) {
var a = get_attribute (attribute);
if (a != null) {
- a.args.remove (argument);
+ a.args.unset (argument);
if (a.args.size == 0) {
attributes.remove (a);
}
diff --git a/vala/valacodewriter.vala b/vala/valacodewriter.vala
index 1d83a20..14e385a 100644
--- a/vala/valacodewriter.vala
+++ b/vala/valacodewriter.vala
@@ -1647,7 +1647,7 @@ public class Vala.CodeWriter : CodeVisitor {
iter = iter.next ();
var keys = new GLib.Sequence<string> ();
- foreach (var key in attr.args.get_keys ()) {
+ foreach (var key in attr.args.keys) {
if (key == "cheader_filename" && sym is Namespace) {
continue;
}
diff --git a/vala/valaflowanalyzer.vala b/vala/valaflowanalyzer.vala
index 9f94a42..9652c15 100644
--- a/vala/valaflowanalyzer.vala
+++ b/vala/valaflowanalyzer.vala
@@ -367,7 +367,7 @@ public class Vala.FlowAnalyzer : CodeVisitor {
phi.set (block, 0);
}
- foreach (Variable variable in assign.get_keys ()) {
+ foreach (Variable variable in assign.keys) {
counter++;
foreach (BasicBlock block in assign.get (variable)) {
work_list.add (block);
diff --git a/vala/valagirparser.vala b/vala/valagirparser.vala
index 742868c..047c505 100644
--- a/vala/valagirparser.vala
+++ b/vala/valagirparser.vala
@@ -118,7 +118,7 @@ public class Vala.GirParser : CodeVisitor {
add_child (child);
}
// merge arguments and take precedence
- foreach (var key in metadata.args.get_keys ()) {
+ foreach (var key in metadata.args.keys) {
args[key] = metadata.args[key];
}
}
@@ -140,7 +140,7 @@ public class Vala.GirParser : CodeVisitor {
public SourceReference source_reference;
public bool used = false;
- public Vala.Map<ArgumentType,Argument> args = new HashMap<ArgumentType,Argument> ();
+ public Map<ArgumentType,Argument> args = new HashMap<ArgumentType,Argument> ();
public ArrayList<Metadata> children = new ArrayList<Metadata> ();
public Metadata (string pattern, string? selector = null, SourceReference? source_reference =
null) {
@@ -181,7 +181,7 @@ public class Vala.GirParser : CodeVisitor {
}
public bool has_argument (ArgumentType key) {
- return args.contains (key);
+ return args.has_key (key);
}
public Expression? get_expression (ArgumentType arg) {
@@ -508,7 +508,7 @@ public class Vala.GirParser : CodeVisitor {
public Metadata metadata = Metadata.empty;
public SourceReference source_reference = null;
public ArrayList<Node> members = new ArrayList<Node> (); // guarantees fields order
- public HashMap<string, ArrayList<Node>> scope = new HashMap<string, ArrayList<Node>>
(str_hash, str_equal);
+ public HashMap<string, ArrayList<Node>> scope = new HashMap<string, ArrayList<Node>> ();
public GirComment comment;
public Symbol symbol;
@@ -551,7 +551,7 @@ public class Vala.GirParser : CodeVisitor {
var nodes = scope[node.name];
nodes.remove (node);
if (nodes.size == 0) {
- scope.remove (node.name);
+ scope.unset (node.name);
}
members.remove (node);
node.parent = null;
@@ -651,7 +651,7 @@ public class Vala.GirParser : CodeVisitor {
}
}
- if (prefix == null && girdata != null && (girdata.contains ("c:symbol-prefix") ||
girdata.contains("c:symbol-prefixes"))) {
+ if (prefix == null && girdata != null && (girdata.has_key ("c:symbol-prefix") ||
girdata.has_key ("c:symbol-prefixes"))) {
/* Use the prefix in the gir. We look up prefixes up to the root.
If some node does not have girdata, we ignore it as i might be
a namespace created due to reparenting. */
@@ -1270,8 +1270,8 @@ public class Vala.GirParser : CodeVisitor {
Node current;
Node old_current;
- Set<string> provided_namespaces = new HashSet<string> (str_hash, str_equal);
- HashMap<UnresolvedSymbol,Symbol> unresolved_symbols_map = new HashMap<UnresolvedSymbol,Symbol>
(unresolved_symbol_hash, unresolved_symbol_equal);
+ Set<string> provided_namespaces = new HashSet<string> ();
+ HashMap<UnresolvedSymbol,Symbol> unresolved_symbols_map = new HashMap<UnresolvedSymbol,Symbol> ((a)
=> {return unresolved_symbol_hash(a);}, (a, b) => {return unresolved_symbol_equal(a, b);});
ArrayList<UnresolvedSymbol> unresolved_gir_symbols = new ArrayList<UnresolvedSymbol> ();
ArrayList<DataType> unresolved_type_arguments = new ArrayList<DataType> ();
@@ -3380,7 +3380,7 @@ public class Vala.GirParser : CodeVisitor {
return;
}
- foreach (var arg_type in metadata.args.get_keys ()) {
+ foreach (var arg_type in metadata.args.keys) {
var arg = metadata.args[arg_type];
if (!arg.used) {
// if metadata is used and argument is not, then it's a unexpected argument
diff --git a/vala/valamarkupreader.vala b/vala/valamarkupreader.vala
index 556853d..60423f2 100644
--- a/vala/valamarkupreader.vala
+++ b/vala/valamarkupreader.vala
@@ -41,7 +41,7 @@ public class Vala.MarkupReader : Object {
int line;
int column;
- Map<string,string> attributes = new HashMap<string,string> (str_hash, str_equal);
+ Map<string,string> attributes = new HashMap<string,string> ();
bool empty_element;
public MarkupReader (string filename) {
@@ -71,8 +71,8 @@ public class Vala.MarkupReader : Object {
* @return map of current attributes
*/
public Map<string,string> get_attributes () {
- var result = new HashMap<string,string> (str_hash, str_equal);
- foreach (var key in attributes.get_keys ()) {
+ var result = new HashMap<string,string> ();
+ foreach (var key in attributes.keys) {
result.set (key, attributes.get (key));
}
return result;
diff --git a/vala/valascope.vala b/vala/valascope.vala
index a2a946b..d77ed9c 100644
--- a/vala/valascope.vala
+++ b/vala/valascope.vala
@@ -58,7 +58,7 @@ public class Vala.Scope {
public void add (string? name, Symbol sym) {
if (name != null) {
if (symbol_table == null) {
- symbol_table = new HashMap<string,Symbol> (str_hash, str_equal);
+ symbol_table = new HashMap<string,Symbol> ();
} else if (lookup (name) != null) {
owner.error = true;
if (owner.name == null && owner.parent_symbol == null) {
@@ -82,7 +82,7 @@ public class Vala.Scope {
}
public void remove (string name) {
- symbol_table.remove (name);
+ symbol_table.unset (name);
}
/**
diff --git a/vala/valaswitchstatement.vala b/vala/valaswitchstatement.vala
index c583f8d..9c382be 100644
--- a/vala/valaswitchstatement.vala
+++ b/vala/valaswitchstatement.vala
@@ -118,7 +118,7 @@ public class Vala.SwitchStatement : CodeNode, Statement {
expression.target_type = expression.value_type.copy ();
expression.target_type.nullable = false;
- var labelset = new HashSet<string> (str_hash, str_equal);
+ var labelset = new HashSet<string> ();
foreach (SwitchSection section in sections) {
section.check (context);
diff --git a/vala/valausedattr.vala b/vala/valausedattr.vala
index 14cdd97..0df1c1a 100644
--- a/vala/valausedattr.vala
+++ b/vala/valausedattr.vala
@@ -27,7 +27,7 @@ using GLib;
* Code visitor to warn about unused attributes
*/
public class Vala.UsedAttr : CodeVisitor {
- public Vala.Map<string,Vala.Set<string>> marked = new HashMap<string,Vala.Set<string>> (str_hash,
str_equal);
+ public Vala.Map<string,Vala.Set<string>> marked = new HashMap<string,Vala.Set<string>> ();
const string[] valac_default_attrs = {
"CCode", "type_signature", "default_value", "set_value_function", "type_id", "cprefix",
"cheader_filename",
@@ -101,7 +101,7 @@ public class Vala.UsedAttr : CodeVisitor {
public void mark (string attribute, string? argument) {
var set = marked.get (attribute);
if (set == null) {
- set = new HashSet<string> (str_hash, str_equal);
+ set = new HashSet<string> ();
marked.set (attribute, set);
}
@@ -127,7 +127,7 @@ public class Vala.UsedAttr : CodeVisitor {
if (set == null) {
Report.warning (attr.source_reference, "attribute `%s' never
used".printf (attr.name));
} else {
- foreach (var arg in attr.args.get_keys()) {
+ foreach (var arg in attr.args.keys) {
if (!set.contains (arg)) {
Report.warning (attr.source_reference, "argument `%s'
never used".printf (arg));
}
diff --git a/vapigen/valagidlparser.vala b/vapigen/valagidlparser.vala
index 731ea26..b879edd 100644
--- a/vapigen/valagidlparser.vala
+++ b/vapigen/valagidlparser.vala
@@ -51,7 +51,7 @@ public class Vala.GIdlParser : CodeVisitor {
* @param context a code context
*/
public void parse (CodeContext context) {
- cname_type_map = new HashMap<string,TypeSymbol> (str_hash, str_equal);
+ cname_type_map = new HashMap<string,TypeSymbol> ();
this.context = context;
context.accept (this);
@@ -88,7 +88,7 @@ public class Vala.GIdlParser : CodeVisitor {
}
private void visit_type (TypeSymbol t) {
- if (!cname_type_map.contains (get_cname (t))) {
+ if (!cname_type_map.has_key (get_cname (t))) {
cname_type_map[get_cname (t)] = t;
}
}
@@ -104,8 +104,8 @@ public class Vala.GIdlParser : CodeVisitor {
current_source_file = source_file;
- codenode_attributes_map = new HashMap<string,string> (str_hash, str_equal);
- codenode_attributes_patterns = new HashMap<PatternSpec*,string> (direct_hash,
(EqualFunc<PatternSpec>) PatternSpec.equal);
+ codenode_attributes_map = new HashMap<string,string> ();
+ codenode_attributes_patterns = new HashMap<PatternSpec*,string> ();
if (FileUtils.test (metadata_filename, FileTest.EXISTS)) {
try {
@@ -1586,9 +1586,9 @@ public class Vala.GIdlParser : CodeVisitor {
current_data_type = cl;
- current_type_symbol_set = new HashSet<string> (str_hash, str_equal);
- var current_type_func_map = new HashMap<string,weak IdlNodeFunction> (str_hash, str_equal);
- var current_type_vfunc_map = new HashMap<string,string> (str_hash, str_equal);
+ current_type_symbol_set = new HashSet<string> ();
+ var current_type_func_map = new HashMap<string,weak IdlNodeFunction> ();
+ var current_type_vfunc_map = new HashMap<string,string> ();
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.FUNCTION) {
@@ -1602,7 +1602,7 @@ public class Vala.GIdlParser : CodeVisitor {
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.FUNCTION) {
// Ignore if vfunc (handled below)
- if (!current_type_vfunc_map.contains (member.name)) {
+ if (!current_type_vfunc_map.has_key (member.name)) {
var m = parse_function ((IdlNodeFunction) member);
if (m != null) {
cl.add_method (m);
@@ -1708,9 +1708,9 @@ public class Vala.GIdlParser : CodeVisitor {
current_data_type = iface;
- current_type_symbol_set = new HashSet<string> (str_hash, str_equal);
- var current_type_func_map = new HashMap<string,weak IdlNodeFunction> (str_hash, str_equal);
- var current_type_vfunc_map = new HashMap<string,string> (str_hash, str_equal);
+ current_type_symbol_set = new HashSet<string> ();
+ var current_type_func_map = new HashMap<string,weak IdlNodeFunction> ();
+ var current_type_vfunc_map = new HashMap<string,string> ();
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.FUNCTION) {
@@ -1724,7 +1724,7 @@ public class Vala.GIdlParser : CodeVisitor {
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.FUNCTION) {
// Ignore if vfunc (handled below)
- if (!current_type_vfunc_map.contains (member.name)) {
+ if (!current_type_vfunc_map.has_key (member.name)) {
var m = parse_function ((IdlNodeFunction) member, true);
if (m != null) {
iface.add_method (m);
@@ -2987,7 +2987,7 @@ public class Vala.GIdlParser : CodeVisitor {
var dot_required = (-1 != codenode.index_of_char ('.'));
var colon_required = (-1 != codenode.index_of_char (':'));
- var pattern_specs = codenode_attributes_patterns.get_keys ();
+ var pattern_specs = codenode_attributes_patterns.keys;
foreach (PatternSpec* pattern in pattern_specs) {
var pspec = codenode_attributes_patterns[pattern];
diff --git a/vapigen/valavapicheck.vala b/vapigen/valavapicheck.vala
index 509645f..52c57ad 100644
--- a/vapigen/valavapicheck.vala
+++ b/vapigen/valavapicheck.vala
@@ -38,7 +38,7 @@ class Vala.VAPICheck : Object {
private void parse_gidl () {
_scope = new ArrayList<string> ();
- _symbols = new HashSet<string> (str_hash, str_equal);
+ _symbols = new HashSet<string> ();
try {
foreach (weak IdlModule module in Idl.parse_file (gidl.filename)) {
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
