public ModuleController()
{
_app_domain_map = new Hashtable ();
_ref_counts = new Hashtable ();
_search_path = new ArrayList ();
_roles = new ArrayList ();
_loader = new ModuleLoader (_search_path, this);
_info_map = new Hashtable ();
}
protected void OpResolve(DepNode _node, ArrayList _parents, ModuleInfo _info, bool checking, DepOps _parentop)
{
Console.WriteLine ("-->> OpResolve called with:");
Console.WriteLine ("---->> _node = {0}", _node == null ? "null" : "not null");
Console.WriteLine ("---->> _node.DepOp = {0}", OpToString (_node.DepOp));
Console.WriteLine ("---->> _parents = {0}", _parents == null ? "null" : "not null");
Console.WriteLine ("---->> _info = {0}", _info == null ? "null" : "not null");
Console.WriteLine ("---->> checking = {0}", checking);
bool _ret;
DepOps _op = _node.DepOp;
if ((_op == DepOps.And) || (_op == DepOps.Not) || (_op == DepOps.Opt) || (_op == DepOps.Or) || (_op == DepOps.Xor)) {
// combo-operators
ArrayList _results = new ArrayList ();
ArrayList _c = new ArrayList ();
foreach (DepNode _child in _node.Children) {
//try {
OpResolve (_child, _parents, _info, checking, _op);
_results.Add (true);
_c.Add (_child.Constraint);
//} catch (Exception e) {
// _results.Add (false);
// _c.Add (_child.Constraint);
//}
}
switch (_op) {
case DepOps.And:
int r = 0;
if (_results == null) {
Console.WriteLine ("_results is NULL!");
}
foreach (bool _result in _results) {
if (!_result) {
if (_parentop != DepOps.Null && _parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: (AND operator)\n\t{1} ({2})",
_info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version)
);
}
}
r++;
}
break;
case DepOps.Not:
foreach (bool _result in _results) {
if (_result) {
if (_parentop != DepOps.Null && _parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: (NOT operator)\n\t{1} ({2})",
_info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version)
);
}
}
}
break;
case DepOps.Opt: // This is optional so stuff is true regardless
break;
case DepOps.Or:
_ret = false;
ArrayList _urexc = new ArrayList ();
r = 0;
foreach (bool _result in _results) {
if (_result)
_ret = true;
else {
_urexc.Add (string.Format("{1} ({2})", _info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version));
}
r++;
}
if (!_ret) {
StringBuilder _sb = new StringBuilder (
string.Format("The following dependency for the module {0} could not be resolved: (OR operator)\n")
);
foreach (string _exc in _urexc) {
_sb.Append(string.Format("\t{0}\n", _exc));
}
if (_parentop != DepOps.Null && _parentop != DepOps.Opt)
throw new UnresolvedDependencyException (_sb.ToString ());
}
break;
case DepOps.Xor:
bool _xt = true;
bool _xf = true;
ArrayList _xexc = new ArrayList ();
r = 0;
_ret = true;
foreach (bool _result in _results) {
if (_result) {
_xf = false;
_xexc.Add (string.Format("{1} ({2}) (True)", _info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version));
}
if (!_result) {
_xt = false;
_xexc.Add (string.Format("{1} ({2}) (False)", _info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version));
}
r++;
}
if (_xt && _xf)
_ret = false;
if (!_xt && _xf)
_ret = false;
if (!_ret) {
StringBuilder _sb = new StringBuilder (
string.Format ("The following dependency for the module {0} could not be resolved: (XOR operator)\n")
);
foreach (string _exc in _xexc) {
_sb.Append (string.Format("\t{0}\n", _exc));
}
if (_parentop != DepOps.Null && _parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (_sb.ToString ());
}
}
break;
}
} else {
DepConstraint _constraint = _node.Constraint;
// single operators
if (SearchForModule (_constraint.Name) == null)
_ret = false;
ModuleInfo _ninfo;
ModuleLoader _loader = new ModuleLoader (_search_path, _controller);
_loader.LoadModule (_parents, _constraint.Name, out _ninfo, true, true);
bool result = true;
Console.WriteLine ("Checking {0}'s version: Empty {1}", _constraint.Name, IsEmptyVersion (_constraint.Version));
Console.WriteLine ("Checking ({0} {1} {2}) Result: {3}", OpToString (_op), _ninfo.Version.ToString(), _constraint.Version.ToString(), VersionMatch (_ninfo.Version, _constraint.Version, _op));
if (!IsEmptyVersion (_constraint.Version)) {
if (!VersionMatch (_ninfo.Version, _constraint.Version, _op)) {
result = false;
}
}
if (!result) {
if (_parentop != DepOps.Null && _parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version, OpToString (_op))
);
}
else
return;
}
if (_controller == null)
Console.WriteLine ("_controller is NULL!");
if (!checking) {
_controller.LoadModule (_constraint.Name);
}
Console.WriteLine ("Checking {0} for {1} (Result: {2})", OpToString (_op), _info.Name, result);
// we got this far, so obviously it loaded okay
}
}
/// <summary>
/// Recursively resolves dependencies given a dependency tree.
/// </summary>
/// <remarks>None.</remarks>
/// <param name="_node">The root node of the tree to resolve.</param>
/// <param name="_parents">The parent modules to use when checking for circular dependencies.</param>
/// <param name="_info">The <see cref="ModuleInfo" /> object representing the module to resolve dependencies for.</param>
/// <param name="opt">Set to true if this pass is optional, otherwise set to false.</param>
/// <exception cref="UnresolvedDependencyException">Thrown if the given dependency cannot be resolved and is not optional.</exception>
/// <exception cref="CircularDependencyException">Thrown if two modules depend on each other.</exception>
protected void OpResolve(DepNode _node, ArrayList _parents, ModuleInfo _info, bool checking, bool opt)
{
bool _ret;
DepOps _op = _node.DepOp;
// This is a large process. I've chosen to use recursion here because it makes sense from a tree
// point of view. Our first step is to check our operator to see if its one of the "combination"
// operators. If it is, we simply recurse through its children and record their results in a
// table (true if they suceeded, false if they failed). Since we're not sure what kind of logic
// we need (and, or, xor) we can't really make a decision at this point. When we go through
// the children, they simply go through this process to until we reach a bottom node, which would
// be one of the "single" operators. They are dealt with in the second part of this function.
if ((_op == DepOps.And) || (_op == DepOps.Opt) || (_op == DepOps.Or) || (_op == DepOps.Xor)) {
// This is our list of results for the children nodes.
ArrayList _results = new ArrayList ();
// This is a list of constraints for the children nodes so we can output sensible information.
ArrayList _c = new ArrayList ();
foreach (DepNode _child in _node.Children) {
// Try to resolve the child node, if it suceeds, store
// true into the results table, if an exception is thrown
// store false into the results table. Store the constraints
// into the constraints table regardless of result so the indexes
// will be identical.
try {
OpResolve (_child, _parents, _info, checking, _op == DepOps.Opt ? true : false);
_results.Add (true);
_c.Add (_child.Constraint);
} catch (Exception e) {
_results.Add (false);
_c.Add (_child.Constraint);
}
}
// This switch statement is where we go through the results table and apply
// the operator logic to the table to figure out if the results sastify
// the given operator.
switch (_op) {
case DepOps.And:
int r = 0;
foreach (bool _result in _results) {
if (!_result) {
if (!opt) {
if (_c[r] != null) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version.ToString(), OpToString (DepOps.And))
);
} else {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({1} operator)",
_info.Name, OpToString (DepOps.And))
);
}
}
}
r++;
}
break;
case DepOps.Opt: // This is optional so stuff is true regardless
break;
case DepOps.Or:
_ret = false;
ArrayList _urexc = new ArrayList ();
r = 0;
foreach (bool _result in _results) {
if (_result)
_ret = true;
else {
if (_c[r] != null)
_urexc.Add (string.Format("{0} ({1})", ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version.ToString()));
}
r++;
}
if (!_ret) {
StringBuilder _sb = new StringBuilder (
string.Format("The following dependency for the module {0} could not be resolved: (OR operator)\n", _info.Name)
);
foreach (string _exc in _urexc) {
_sb.Append(string.Format("\t{0}\n", _exc));
}
if (!opt)
throw new UnresolvedDependencyException (_sb.ToString ());
}
break;
case DepOps.Xor:
bool _xt = true;
bool _xf = true;
ArrayList _xexc = new ArrayList ();
r = 0;
_ret = true;
foreach (bool _result in _results) {
if (_result) {
_xf = false;
if (_c[r] != null)
_xexc.Add (string.Format("{0} ({1}) (True)", ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version.ToString()));
}
if (!_result) {
_xt = false;
if (_c[r] != null)
_xexc.Add (string.Format("{0} ({1}) (False)", ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version.ToString()));
}
r++;
}
// If one of these is still true, that means all of the other results are true or false.
if (_xt || _xf)
_ret = false;;
if (!_ret) {
StringBuilder _sb = new StringBuilder (
string.Format ("The following dependency for the module {0} could not be resolved: (XOR operator)\n", _info.Name)
);
foreach (string _exc in _xexc) {
_sb.Append (string.Format("\t{0}\n", _exc));
}
if (!opt) {
throw new UnresolvedDependencyException (_sb.ToString ());
}
}
break;
}
} else {
DepConstraint _constraint = _node.Constraint;
foreach (string _parent in _parents) {
if (_parent == _constraint.Name) {
throw new CircularDependencyException (string.Format ("{0} and {1} have a circular dependency on each other", _parent, _info.Name));
}
}
// single operators
if (SearchForModule (_constraint.Name) == null)
_ret = false;
ModuleInfo _ninfo = null;
ModuleLoader _loader = new ModuleLoader (_search_path, _controller);
try {
if (!_parents.Contains (_info.Name))
_parents.Add (_info.Name);
_loader.LoadModule (_parents, _constraint.Name, out _ninfo, true, true);
} catch (CircularDependencyException ce) {
throw ce;
} catch (Exception) {
if (!opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version.ToString(), OpToString (_op))
);
}
}
if (_op == DepOps.Equal || _op == DepOps.GreaterThan || _op == DepOps.GreaterThanEqual || _op == DepOps.LessThan || _op == DepOps.LessThanEqual || _op == DepOps.NotEqual) {
if (!IsEmptyVersion (_constraint.Version)) {
if (!VersionMatch (_ninfo.Version, _constraint.Version, _op)) {
if (!opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version.ToString(), OpToString (_op))
);
}
}
}
if (!checking) {
_controller.LoadModule (_constraint.Name);
_parents.Sort ();
ArrayList _seen = new ArrayList ();
_seen.Add (_info.Name);
_seen.Add (_constraint.Name);
foreach (string _p in _parents) {
if (!_seen.Contains (_p)) {
_controller.IncRef (_constraint.Name);
_seen.Add (_p);
}
}
}
}
if (_op == DepOps.Loaded) {
if (_controller.Loader.SearchForModule (_constraint.Name) == null)
{
if (!opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version.ToString(), OpToString (_op))
);
}
}
if (!checking) {
_controller.LoadModule (_constraint.Name);
_parents.Sort ();
ArrayList _seen = new ArrayList ();
_seen.Add (_info.Name);
_seen.Add (_constraint.Name);
foreach (string _p in _parents) {
if (!_seen.Contains (_p)) {
_controller.IncRef (_constraint.Name);
_seen.Add (_p);
}
}
}
}
if (_op == DepOps.NotLoaded) {
if (_controller.IsLoaded (_constraint.Name)) {
if (_controller.RefCount (_constraint.Name) > 1) {
if (!opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version.ToString(), OpToString (_op))
);
}
}
if (!checking) {
_controller.UnloadModule (_constraint.Name);
}
}
}
}
}
protected void OpResolve(DepNode _node, ArrayList _parents, ModuleInfo _info, bool checking, DepOps _parentop)
{
bool _ret;
DepOps _op = _node.DepOp;
if ((_op == DepOps.And) || (_op == DepOps.Opt) || (_op == DepOps.Or) || (_op == DepOps.Xor)) {
// combo-operators
ArrayList _results = new ArrayList ();
ArrayList _c = new ArrayList ();
foreach (DepNode _child in _node.Children) {
try {
OpResolve (_child, _parents, _info, checking, _op);
_results.Add (true);
_c.Add (_child.Constraint);
} catch (Exception e) {
_results.Add (false);
_c.Add (_child.Constraint);
}
}
switch (_op) {
case DepOps.And:
int r = 0;
foreach (bool _result in _results) {
if (!_result) {
if (_parentop != DepOps.Opt) {
if (_c[r] != null) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version.ToString(), OpToString (DepOps.And))
);
} else {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({1} operator)",
_info.Name, OpToString (DepOps.And))
);
}
}
}
r++;
}
break;
case DepOps.Opt: // This is optional so stuff is true regardless
break;
case DepOps.Or:
_ret = false;
ArrayList _urexc = new ArrayList ();
r = 0;
foreach (bool _result in _results) {
if (_result)
_ret = true;
else {
if (_c[r] != null)
_urexc.Add (string.Format("{0} ({1})", ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version.ToString()));
}
r++;
}
if (!_ret) {
StringBuilder _sb = new StringBuilder (
string.Format("The following dependency for the module {0} could not be resolved: (OR operator)\n", _info.Name)
);
foreach (string _exc in _urexc) {
_sb.Append(string.Format("\t{0}\n", _exc));
}
if (_parentop != DepOps.Opt)
throw new UnresolvedDependencyException (_sb.ToString ());
}
break;
case DepOps.Xor:
bool _xt = true;
bool _xf = true;
ArrayList _xexc = new ArrayList ();
r = 0;
_ret = true;
foreach (bool _result in _results) {
if (_result) {
_xf = false;
if (_c[r] != null)
_xexc.Add (string.Format("{0} ({1}) (True)", ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version.ToString()));
}
if (!_result) {
_xt = false;
if (_c[r] != null)
_xexc.Add (string.Format("{0} ({1}) (False)", ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version.ToString()));
}
r++;
}
// If one of these is still true, that means all of the other results are true or false.
if (_xt || _xf)
_ret = false;;
if (!_ret) {
StringBuilder _sb = new StringBuilder (
string.Format ("The following dependency for the module {0} could not be resolved: (XOR operator)\n", _info.Name)
);
foreach (string _exc in _xexc) {
_sb.Append (string.Format("\t{0}\n", _exc));
}
if (_parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (_sb.ToString ());
}
}
break;
}
} else {
DepConstraint _constraint = _node.Constraint;
foreach (string _parent in _parents) {
if (_parent == _constraint.Name) {
throw new CircularDependencyException (string.Format ("{0} and {1} have a circular dependency on each other", _parent, _info.Name));
}
}
// single operators
if (SearchForModule (_constraint.Name) == null)
_ret = false;
ModuleInfo _ninfo = null;
ModuleLoader _loader = new ModuleLoader (_search_path, _controller);
try {
if (!_parents.Contains (_info.Name))
_parents.Add (_info.Name);
_loader.LoadModule (_parents, _constraint.Name, out _ninfo, true, true);
} catch (CircularDependencyException ce) {
throw ce;
} catch (Exception) {
if (_parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version.ToString(), OpToString (_op))
);
}
}
if (_op == DepOps.Equal || _op == DepOps.GreaterThan || _op == DepOps.GreaterThanEqual || _op == DepOps.LessThan || _op == DepOps.LessThanEqual || _op == DepOps.NotEqual) {
if (!IsEmptyVersion (_constraint.Version)) {
if (!VersionMatch (_ninfo.Version, _constraint.Version, _op)) {
if (_parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version.ToString(), OpToString (_op))
);
}
}
}
if (!checking) {
_controller.LoadModule (_constraint.Name);
_parents.Sort ();
ArrayList _seen = new ArrayList ();
_seen.Add (_info.Name);
_seen.Add (_constraint.Name);
foreach (string _p in _parents) {
if (!_seen.Contains (_p)) {
_controller.IncRef (_constraint.Name);
_seen.Add (_p);
}
}
}
}
if (_op == DepOps.Loaded) {
if (_controller.Loader.SearchForModule (_constraint.Name) == null)
{
if (_parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version.ToString(), OpToString (_op))
);
}
}
if (!checking) {
_controller.LoadModule (_constraint.Name);
_parents.Sort ();
ArrayList _seen = new ArrayList ();
_seen.Add (_info.Name);
_seen.Add (_constraint.Name);
foreach (string _p in _parents) {
if (!_seen.Contains (_p)) {
_controller.IncRef (_constraint.Name);
_seen.Add (_p);
}
}
}
}
if (_op == DepOps.NotLoaded) {
if (_controller.IsLoaded (_constraint.Name)) {
if (_controller.RefCount (_constraint.Name) > 1) {
if (_parentop != DepOps.Opt) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version.ToString(), OpToString (_op))
);
}
}
if (!checking) {
_controller.UnloadModule (_constraint.Name);
}
}
}
}
}
protected void OpResolve(DepNode _node, ArrayList _parents, ModuleInfo _info, bool checking)
{
bool _ret;
DepOps _op = _node.DepOp;
DepConstraint _constraint = _node.Constraint;
if ((_op == DepOps.And) || (_op == DepOps.Not) || (_op == DepOps.Opt) || (_op == DepOps.Or) || (_op == DepOps.Xor)) {
// combo-operators
ArrayList _results = new ArrayList ();
ArrayList _c = new ArrayList ();
foreach (DepNode _child in _node.Children) {
try {
OpResolve (_child, _parents, _info, checking);
_results.Add (true);
_c.Add (_child.Constraint);
} catch (Exception e) {
_results.Add (false);
_c.Add (_child.Constraint);
}
}
switch (_op) {
case DepOps.And:
int r = 0;
foreach (bool _result in _results) {
if (!_result) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: (AND operator)\n\t{1} ({2})",
_info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version)
);
}
r++;
}
break;
case DepOps.Not:
foreach (bool _result in _results) {
if (_result)
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: (NOT operator)\n\t{1} ({2})",
_info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version)
);
}
break;
case DepOps.Opt: // This is optional so stuff is true regardless
break;
case DepOps.Or:
_ret = false;
ArrayList _urexc = new ArrayList ();
r = 0;
foreach (bool _result in _results) {
if (_result)
_ret = true;
else {
_urexc.Add (string.Format("{1} ({2})", _info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version));
}
r++;
}
if (!_ret) {
StringBuilder _sb = new StringBuilder (
string.Format("The following dependency for the module {0} could not be resolved: (OR operator)\n")
);
foreach (string _exc in _urexc) {
_sb.Append(string.Format("\t{0}\n", _exc));
}
throw new UnresolvedDependencyException (_sb.ToString ());
}
break;
case DepOps.Xor:
bool _xt = true;
bool _xf = true;
ArrayList _xexc = new ArrayList ();
r = 0;
_ret = true;
foreach (bool _result in _results) {
if (_result) {
_xf = false;
_xexc.Add (string.Format("{1} ({2}) (True)", _info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version));
}
if (!_result) {
_xt = false;
_xexc.Add (string.Format("{1} ({2}) (False)", _info.Name, ((DepConstraint)_c[r]).Name, ((DepConstraint)_c[r]).Version));
}
r++;
}
if (_xt || _xf)
_ret = false;
if (!_ret) {
StringBuilder _sb = new StringBuilder (
string.Format ("The following dependency for the module {0} could not be resolved: (XOR operator)\n")
);
foreach (string _exc in _xexc) {
_sb.Append (string.Format("\t{0}\n", _exc));
}
throw new UnresolvedDependencyException (_sb.ToString ());
}
break;
}
} else {
// single operators
if (SearchForModule (_constraint.Name) == null)
_ret = false;
ModuleInfo _ninfo;
ModuleLoader _loader = new ModuleLoader (_search_path, this);
_loader.LoadModule (_parents, _constraint.Name, out _ninfo, true);
if ((_op == DepOps.Equal) || (_op == DepOps.GreaterThan) || (_op == DepOps.GreaterThanEqual) || (_op == DepOps.LessThan)
|| (_op == DepOps.LessThanEqual) || (_op == DepOps.NotEqual)) {
if (!IsEmptyVersion (_constraint.Version)) {
if (!VersionMatch (_constraint.Version, _ninfo.Version, _op)) {
throw new UnresolvedDependencyException (
string.Format("The following dependency for the module {0} could not be resolved: ({3} operator)\n\t{1} ({2})",
_info.Name, _constraint.Name, _constraint.Version, OpToString (_op))
);
}
}
if (!checking) {
_controller.LoadModule (_constraint.Name);
}
}
// we got this far, so obviously it loaded okay
}
}
