public NodeEnumerator(Node node) { _node = _root = node; _first = true; _nodeEnumerators = new ArrayRig <Teple <IEnumerator <Node>, bool> >(); _currentEnumerator = new ArrayRig <Node>(1).GetEnumerator(); }
/// <summary> /// Manually submit all unsubmitted changes to rows. /// </summary> public void SubmitChanges() { // ensure initialization if (_initialize) { Initialize(); } // if no updated collections - skip if (_currentCollections.Count == 0) { return; } _lock.Take(); // copy the updated collections ArrayRig <RowCollection> collections = _currentCollections; _currentCollections = new ArrayRig <RowCollection>(collections.Count); _lock.Release(); // iterate all updated collections foreach (RowCollection collection in collections) { // run an update for the collection Update(collection, true); } collections.Dispose(); }
/// <summary> /// Initialize a new ThreadHandle that will start a new Thread. /// If memory parameter is 0 this handle will manage the thread that called the constructor. /// </summary> public ThreadHandle(long memory) { // initialize the required parameters Needles = new ArrayRig <Needle>(); Handles.Take(); if (memory == 0) { Thread = Thread.CurrentThread; Thread.Priority = ThreadPriority.AboveNormal; ThreadHandle.Main = this; Thread.Name = "Main"; } else { Thread = new Thread(new ThreadStart(Run), (int)memory); Thread.Name = (Handles.Item.Count + 1).ToString(); } Id = Thread.ManagedThreadId; Handles.Item.Add(this); _handleMap.TakeItem()[Id] = this; _handleMap.Release(); Handles.Release(); _iteration = -1; _index = -1; }
/// <summary> /// Validate the form with the specified post parameters. Returns /// an empty array if validation succeeded or an array with user /// friendly error messages if the validation failed. /// </summary> public virtual ArrayRig <string> Validate(HttpPostParams parameters, ArrayRig <string> errors = null) { if (_update) { Update(); } // create a collection of potential errors if (errors == null) { errors = new ArrayRig <string>(1); } if (parameters == null) { errors.Add("Malformed or missing request parameters."); return(errors); } // iterate and validate the child forms foreach (var form in _forms) { form.Validate(parameters, errors); } // iterate and validate the input elements foreach (var input in _input) { IHttpPostParam parameter = parameters[input.Key]; input.Value.Validate(parameter, errors); } // return the collection of error messages return(errors); }
//----------------------------------// //----------------------------------// internal JsMethod(JsClass jsClass, MethodInfo method) { Parameters = new Dictionary <string, Js>(); Commands = new ArrayRig <JsCommand>(); // does the method return a string? if (method.ReturnType != typeof(string)) { throw new InvalidOperationException("JsMethod '" + method.Name + "' doesn't return a string."); } // iterate the parameters foreach (var parameter in method.GetParameters()) { // ensure each parameter is a Js type if (!Js.IsAncestor(parameter.ParameterType)) { throw new InvalidOperationException("Parameter '" + parameter.Name + "' of method '" + method.Name + "' in class '" + method.DeclaringType.Name + "' doesn't inherit from Js."); } // add the parameter Parameters.Add(parameter.Name, parameter.HasDefaultValue ? (Js)parameter.DefaultValue : null); } // add the string returned from the method as the javascript command Commands.Add(new JsCommandString((string)method.Invoke(jsClass, new object[Parameters.Count]))); }
//-------------------------------------------// /// <summary> /// Initialize an element rule with a tag to parse and parameters to return. /// </summary> public ExtractUrl(IAction <string> onUrl = null, ArrayRig <Protocol> protocols = null) { if (onUrl != null) { OnUrl = new Shared <IAction <string> >(onUrl); OnUrlSet = true; } // initialize the tree search instance ProtocolSearch = new TreeSearch <char, char[]>(); // were the protocols specified? if (protocols == null) { // no, set default protocols = new ArrayRig <Protocol>(new [] { Protocol.Http, Protocol.Https }); } // iterate the protocols foreach (var protocol in protocols) { char[] chars = Protocols.Get(protocol).ToCharArray(); ProtocolSearch.Add(chars, new ArrayRig <char>(chars)); } }
/// <summary> /// Add an enumerable collection as keys. /// </summary> public void Add(TValue value, System.Collections.Generic.IEnumerable <TKey> keys) { ArrayRig <TKey> rig = new ArrayRig <TKey>(); rig.AddCollection(keys); Add(value, rig); }
//-------------------------------------------// /// <summary> /// Initialize an element rule with a tag to parse and parameters to return. /// </summary> public ParseLine(ExtractLine extract) { _extract = extract; _line = new char[_extract.CharBuffer]; _reqParsersSet = extract.ReqExtracts != null; if (_reqParsersSet) { _reqParsers = new ArrayRig <Parse>(); foreach (Extract req in extract.ReqExtracts) { _reqParsers.Add(req.GetParser()); } } _subParsersSet = extract.SubExtracts != null; if (_subParsersSet) { _subParsers = new ArrayRig <Parse>(); foreach (Extract sub in extract.SubExtracts) { _subParsers.Add(sub.GetParser()); } } }
/// <summary> /// Create a new udp connection to handle communication to a single endpoint from the specified socket. /// </summary> public UdpConnection(UdpServer server, Socket socket, IPEndPoint remoteEndpoint) { // persist the server Server = server; RemoteEndPoint = remoteEndpoint; _timeoutTimer = new Timer(_timeoutMilliseconds, ActionSet.New(ProcessError, new TimeoutException("UdpConnection timeout."))); _header = new UdpHeader(); _header.Compression = _defaultCompression = DecompressionMethods.None; // create the encoder _encoder = Encoding.UTF8.GetEncoder(); _lock = new Lock(); _message = new UdpMessage(this); _messages = new ArrayRig <UdpMessage>(); _onMessage = new ActionPop <UdpMessage>(); _errors = new ArrayRig <Exception>(); _onError = new ActionPop <Exception>(); // create an async socket to manage the socket AsyncSocket = new AsyncUdpSocket(socket, (IPEndPoint)socket.LocalEndPoint, OnReceived, ProcessError); AsyncSocket.TargetEndPoint = RemoteEndPoint; }
//-------------------------------------------// /// <summary> /// Derive a collection of one type from another, optionally with a predicate. /// </summary> public static ArrayRig <B> Derive <A, B>(this IEnumerable <A> collection, Func <A, B> mapper, Func <A, bool> predicate = null) { ArrayRig <B> rig = new ArrayRig <B>(); // was the predicate supplied? if (predicate == null) { // no, perform the mapping without foreach (A item in collection) { rig.Add(mapper(item)); } } else { // yes, perform the mapping with the predicate foreach (A item in collection) { if (predicate(item)) { rig.Add(mapper(item)); } } } return(rig); }
/// <summary> /// Dispose of the data cluster and all related resources. /// </summary> public void Dispose() { ArrayRig <Keyspace> keyspaces = new ArrayRig <Keyspace>(); // iterate and dispose of Keyspaces foreach (var keyspace in Keyspaces) { keyspaces.Add(keyspace.Value); } foreach (var keyspace in keyspaces) { keyspace.Dispose(); } _lock.Take(); Keyspaces.Clear(); Keyspaces = null; _lock.Release(); // remove the cluster from the manager ManagerCql.RemoveCluster(this); // dispose of the cassandra cluster Cluster.Shutdown(); Cluster.Dispose(); }
/// <summary> /// Create a new incoming udp connection to handle communication to a single endpoint. /// </summary> public UdpConnection(UdpServer server, IPEndPoint remoteEndpoint, IPEndPoint localEndpoint, byte[] buffer, int count) { // persist the server Server = server; RemoteEndPoint = remoteEndpoint; _timeoutTimer = new Timer(_timeoutMilliseconds, ActionSet.New(ProcessError, new TimeoutException("UdpConnection timeout."))); _header = new UdpHeader(); _header.Compression = _defaultCompression = DecompressionMethods.None; // create the encoder _encoder = Encoding.UTF8.GetEncoder(); _lock = new Lock(); _message = new UdpMessage(this); _messages = new ArrayRig <UdpMessage>(); _onMessage = new ActionPop <UdpMessage>(); _errors = new ArrayRig <Exception>(); _onError = new ActionPop <Exception>(); // call on received for the first buffer OnReceived(RemoteEndPoint, buffer, count); // create a socket instance for the udp connection var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); // create an async socket to manage the socket AsyncSocket = new AsyncUdpSocket(socket, localEndpoint, OnReceived, ProcessError); AsyncSocket.TargetEndPoint = RemoteEndPoint; }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public virtual void Dispose() { if (_stopped) { return; } _stopped = true; try { // get a collection of the current connections var connections = new ArrayRig <UdpConnection>(); foreach (var entry in _connections.TakeItem()) { connections.Add(entry.Value); } _connections.Release(); // dispose of each connection foreach (var connection in connections) { connection.Dispose(); } // dispose of the listenning socket AsyncSocket.Dispose(); _socket.Dispose(); } catch (Exception ex) { Log.Error("Exception disposing of UDP server connections.", ex); } }
/// <summary> /// Add a root path and callback for the sub path. /// </summary> public void Add(string path, HttpMethod methods, IAction <string, HttpRequest> callback) { if (string.IsNullOrEmpty(path)) { throw new InvalidOperationException("Null or empty paths aren't allowed. Use the DefaultCallback field."); } path = path.ToLowercase(); if (path[0] == Chars.ForwardSlash) { path = path.Substring(1); } _lock.Take(); ArrayRig <Route> routes; if (_routes.TryGetValue(path, out routes)) { foreach (var route in routes) { if (route.Methods.Is(methods)) { throw new Exception("Route methods cannot be defined twice."); } } routes.Add(new Route(methods, callback)); } else { routes = new ArrayRig <Route>(); routes.Add(new Route(methods, callback)); _routes.Add(path, routes); } _lock.Release(); }
private static void Add(IConnection connection, bool tryLock) { // get the lock if (tryLock && !(tryLock = _lock.TryTake)) { _lock.TryLock(new Act <IConnection, bool>(Add, connection, false)); return; } // get the list of connections of that type Type sourceType = connection.GetType(); ArrayRig <IConnection> connections; if (!_sources.TryGetValue(sourceType, out connections)) { _sources[sourceType] = connections = new ArrayRig <IConnection>(); } // add the connection _sources[sourceType].Add(connection); // if manually locked, unlock if (tryLock) { _lock.Release(); } }
/// <summary> /// Dispose of the blob stream. /// </summary> protected override void Dispose(bool disposing) { if (!disposing) { return; } _lock.Take(); FlushInternal(); if (_sections != null) { // dispose of the sections collection for (int i = _sections.Count - 1; i >= 0; --i) { if (_sections[i] == null) { continue; } _sections[i].Bytes = null; } _sections.Dispose(); _sections = null; } _lock.Release(); }
/// <summary> /// Add or Get a connection synchronously to the connections known by the Api Manager. /// This doesn't open the connection. /// </summary> public static C Get <C>(string path) where C : Connection <C>, new() { // get the lock _lock.Take(); Type sourceType = typeof(C); ArrayRig <IConnection> connections; if (!_sources.TryGetValue(sourceType, out connections)) { _sources[sourceType] = connections = new ArrayRig <IConnection>(); } // try get the connection C connection = connections.GetSingle(c => c.Path == path) as C; if (connection == null) { // connection doesn't exist, create it connection = new C(); connection.Path = path; _sources[sourceType].Add(connection); } // if manually locked, unlock _lock.Release(); return(connection); }
/// <summary> /// Get a supported class from the connection. Resource is unlocked after the action called is ended. /// </summary> public static void Get <T, C>(string path, out Teple <LockShared, T> resource) where C : Connection <C>, IGetValue <T>, new() { _lock.Take(); // get the type of connection Type sourceType = typeof(C); ArrayRig <IConnection> source; // check if there are currently any types of connections like this if (!_sources.TryGetValue(sourceType, out source)) { // create the dictionary source = new ArrayRig <IConnection>(); _sources[sourceType] = source; } // try get the connection C connection = source.GetSingle(c => c.Path == path) as C; // if the connection doesn't exist if (connection == null) { // create a new connection connection = new C(); connection.Path = path; // add to the source source.Add(connection); } // unlock the sources lock _lock.Release(); // get the resource connection.Get(out resource); }
private static void Get <T, C>(C connection, Act <T> onResource, bool tryLock) where C : Connection <C>, IGetValue <T>, new() { // get the lock if (tryLock && !(tryLock = _lock.TryTake)) { _lock.TryLock(new Act <C, Act <T>, bool>(Get <T, C>, connection, onResource, false)); return; } Type sourceType = typeof(C); ArrayRig <IConnection> source; // check if there are currently any types of connections like this if (!_sources.TryGetValue(sourceType, out source)) { // create the source dictionary and add it _sources[sourceType] = source = new ArrayRig <IConnection>(); } // does the connection exist in source? if (!source.Contains(connection)) { // add to the connections source.Add(connection); } // if manually locked, unlock if (tryLock) { _lock.Release(); } // get the resource connection.Get(onResource); }
//----------------------------------// /// <summary> /// Initialize a wav file reader. /// </summary> public WavInterpret() { BufferCount(24); Left = new ArrayRig <double>(1000); Right = new ArrayRig <double>(1000); }
/// <summary> /// Initialize a new set of headers. /// </summary> public HttpResponseHeaders(bool includeDefault) { // initialize the collection _definedHeaders = new ArrayRig <Teple <HttpResponseHeader, Teple <string, int> > >(12); _definedSingles = new Dictionary <HttpResponseHeader, string>(); _customHeaders = new ArrayRig <Teple <string, Teple <string, int> > >(); _customSingles = new Dictionary <string, string>(); _builder = new StringBuilder(); // should the default headers be added? if (includeDefault) { // set the default header prefix Version = "Http/1.1"; StatusCode = 200; Set(HttpResponseHeader.Server, "Efz"); Set(HttpResponseHeader.AcceptRanges, "bytes"); Set(HttpResponseHeader.Vary, "Accept-Encoding"); Set(HttpResponseHeader.Connection, "keep-alive"); Set(HttpResponseHeader.ContentEncoding, "gzip"); Set(HttpResponseHeader.ContentType, "text/html; charset=UTF-8"); } else { _statusCode = 0; _version = _statusDescription = string.Empty; } }
/// <summary> /// Add a child style. /// </summary> public void Add(Style child) { if (_children == null) { _children = new ArrayRig <Style>(); } _children.Add(child); }
//-------------------------------------------// /// <summary> /// Initialize with the functions necessary to perform calculations on a generic type. /// </summary> public Average(int _batchSize, int _batchNumber, double _batchWeight = 1.0) { batchSize = _batchSize; batchCount = _batchNumber; BatchWeight = _batchWeight; batch = new ArrayRig <double>(batchSize); batches = new ArrayRig <double>(batchCount); }
/// <summary> /// Add a sub extract that must exist within this section for it to be /// parsed successfully. /// </summary> public void AddRequirement(Extract extract) { if (ReqExtracts == null) { ReqExtracts = new ArrayRig <Extract>(); } ReqExtracts.Add(extract); }
/// <summary> /// Add a sub extract to act on the body of the element if it exists. /// </summary> public void AddBodyExtract(Extract extract) { if (BodyExtracts == null) { BodyExtracts = new ArrayRig <Extract>(); } BodyExtracts.Add(extract); }
/// <summary> /// Add a sub extract that will be parsed on a successful /// section. /// </summary> public void AddSubExtract(Extract extract) { if (SubExtracts == null) { SubExtracts = new ArrayRig <Extract>(); } SubExtracts.Add(extract); }
/// <summary> /// Add a sub extract to act on the body of the element if it exists. /// </summary> public void AddSubExtract(Extract extract) { if (!SubExtractSet) { SubExtractSet = true; SubExtract = new ArrayRig <Extract>(); } SubExtract.Add(extract); }
/// <summary> /// Add or Set a search node to the current search branches. /// </summary> public void Add(TValue value, params Struct <TKey[], bool>[] keySets) { var sets = new ArrayRig <Struct <ArrayRig <TKey>, bool> >(keySets.Length); foreach (var s in keySets) { sets.Add(new Struct <ArrayRig <TKey>, bool>(new ArrayRig <TKey>(s.ArgA), s.ArgB)); } Add(value, sets); }
/// <summary> /// Add or Set a search node to the current search branches. /// </summary> public void Add(TValue value, ArrayRig <Struct <TKey[], bool> > keySets) { var sets = new ArrayRig <Struct <ArrayRig <TKey>, bool> >(keySets.Count); foreach (var s in keySets) { sets.Add(new Struct <ArrayRig <TKey>, bool>(new ArrayRig <TKey>(s.ArgA), s.ArgB)); } Add(value, sets); }
/// <summary> /// Add a node to this nodes array collection. /// </summary> public void Add(Node node) { if (!_arraySet) { Array = new ArrayRig <Node>(); _arraySet = true; } node._parent = this; _array.Add(node); }