public static Query GetQuery(Database database, string listDocId) { View view = database.GetView(ViewName); if (view.Map == null) { view.Map += (IDictionary<string, object> document, EmitDelegate emitter)=> { if (Task.DocType.Equals(document.Get("type"))) { var keys = new AList<object>(); keys.AddItem(document.Get("list_id")); keys.AddItem(document.Get("created_at")); emitter(keys, document); } }; } Query query = view.CreateQuery(); query.Descending = true; IList<object> startKeys = new AList<object>(); startKeys.AddItem(listDocId); startKeys.AddItem(new Dictionary<string, object>()); IList<object> endKeys = new AList<object>(); endKeys.AddItem(listDocId); query.StartKey = startKeys; query.EndKey = endKeys; return query; }
public virtual void TestDatabase() { Send("PUT", "/database", Status.Created, null); IDictionary<string, object> dbInfo = (IDictionary<string, object>)Send("GET", "/database" , Status.Ok, null); NUnit.Framework.Assert.AreEqual(0, dbInfo.Get("doc_count")); NUnit.Framework.Assert.AreEqual(0, dbInfo.Get("update_seq")); NUnit.Framework.Assert.IsTrue((int)dbInfo.Get("disk_size") > 8000); Send("PUT", "/database", Status.PreconditionFailed, null); Send("PUT", "/database2", Status.Created, null); IList<string> allDbs = new AList<string>(); allDbs.AddItem("cblite-test"); allDbs.AddItem("database"); allDbs.AddItem("database2"); Send("GET", "/_all_dbs", Status.Ok, allDbs); dbInfo = (IDictionary<string, object>)Send("GET", "/database2", Status.Ok, null); NUnit.Framework.Assert.AreEqual("database2", dbInfo.Get("db_name")); Send("DELETE", "/database2", Status.Ok, null); allDbs.Remove("database2"); Send("GET", "/_all_dbs", Status.Ok, allDbs); Send("PUT", "/database%2Fwith%2Fslashes", Status.Created, null); dbInfo = (IDictionary<string, object>)Send("GET", "/database%2Fwith%2Fslashes", Status .Ok, null); NUnit.Framework.Assert.AreEqual("database/with/slashes", dbInfo.Get("db_name")); }
/// <exception cref="NBoilerpipe.BoilerpipeProcessingException"></exception> public bool Process(TextDocument doc) { bool changes = false; IList<TextBlock> blocks = doc.GetTextBlocks(); IList<TextBlock> blocksNew = new AList<TextBlock>(); foreach (TextBlock tb in blocks) { string text = tb.GetText(); string[] paragraphs = text.Split("[\n\r]+"); if (paragraphs.Length < 2) { blocksNew.AddItem(tb); continue; } bool isContent = tb.IsContent(); ICollection<string> labels = tb.GetLabels(); foreach (string p in paragraphs) { TextBlock tbP = new TextBlock(p); tbP.SetIsContent(isContent); tbP.AddLabels(labels); blocksNew.AddItem(tbP); changes = true; } } if (changes) { blocks.Clear(); Sharpen.Collections.AddAll(blocks, blocksNew); } return changes; }
public virtual void LogAllCommits() { IList<RevCommit> commits = new AList<RevCommit>(); Git git = Git.Wrap(db); WriteTrashFile("Test.txt", "Hello world"); git.Add().AddFilepattern("Test.txt").Call(); commits.AddItem(git.Commit().SetMessage("initial commit").Call()); git.BranchCreate().SetName("branch1").Call(); Ref checkedOut = git.Checkout().SetName("branch1").Call(); NUnit.Framework.Assert.AreEqual("refs/heads/branch1", checkedOut.GetName()); WriteTrashFile("Test1.txt", "Hello world!"); git.Add().AddFilepattern("Test1.txt").Call(); commits.AddItem(git.Commit().SetMessage("branch1 commit").Call()); checkedOut = git.Checkout().SetName("master").Call(); NUnit.Framework.Assert.AreEqual("refs/heads/master", checkedOut.GetName()); WriteTrashFile("Test2.txt", "Hello world!!"); git.Add().AddFilepattern("Test2.txt").Call(); commits.AddItem(git.Commit().SetMessage("branch1 commit").Call()); Iterator<RevCommit> log = git.Log().All().Call().Iterator(); NUnit.Framework.Assert.IsTrue(log.HasNext()); NUnit.Framework.Assert.IsTrue(commits.Contains(log.Next())); NUnit.Framework.Assert.IsTrue(log.HasNext()); NUnit.Framework.Assert.IsTrue(commits.Contains(log.Next())); NUnit.Framework.Assert.IsTrue(log.HasNext()); NUnit.Framework.Assert.IsTrue(commits.Contains(log.Next())); NUnit.Framework.Assert.IsFalse(log.HasNext()); }
/// <exception cref="Kirikiri.Tjs2.VariantException"></exception> /// <exception cref="Kirikiri.Tjs2.TJSException"></exception> public static void SaveStructuredDataForObject(Dispatch2 dsp, AList<Dispatch2> stack , TextWriteStreamInterface stream, string indentstr) { // check object recursion int count = stack.Count; for (int i = 0; i < count; i++) { Dispatch2 d = stack[i]; if (d == dsp) { // object recursion detected stream.Write("null /* object recursion detected */"); return; } } // determin dsp's object type DictionaryNI dicni; ArrayNI arrayni; if (dsp != null) { dicni = (DictionaryNI)dsp.GetNativeInstance(DictionaryClass.ClassID); if (dicni != null) { // dictionary stack.AddItem(dsp); dicni.SaveStructuredData(stack, stream, indentstr); stack.Remove(stack.Count - 1); return; } else { arrayni = (ArrayNI)dsp.GetNativeInstance(ArrayClass.ClassID); if (arrayni != null) { // array stack.AddItem(dsp); arrayni.SaveStructuredData(stack, stream, indentstr); stack.Remove(stack.Count - 1); return; } else { // other objects stream.Write("null /* (object) \""); // stored as a null Variant val = new Variant(dsp, dsp); stream.Write(LexBase.EscapeC(val.AsString())); stream.Write("\" */"); return; } } } stream.Write("null"); }
/// <exception cref="System.IO.IOException"></exception> //private IDictionary<DerObjectIdentifier, Asn1Encodable> ExtendUnsignedAttributes(IDictionary // <DerObjectIdentifier, Asn1Encodable> unsignedAttrs, X509Certificate signingCertificate // , DateTime signingDate, CertificateSource optionalCertificateSource) private IDictionary ExtendUnsignedAttributes(IDictionary unsignedAttrs , X509Certificate signingCertificate, DateTime signingDate , CertificateSource optionalCertificateSource) { ValidationContext validationContext = certificateVerifier.ValidateCertificate(signingCertificate , signingDate, optionalCertificateSource, null, null); try { IList<X509CertificateStructure> certificateValues = new AList<X509CertificateStructure >(); AList<CertificateList> crlValues = new AList<CertificateList>(); AList<BasicOcspResponse> ocspValues = new AList<BasicOcspResponse>(); foreach (CertificateAndContext c in validationContext.GetNeededCertificates()) { if (!c.Equals(signingCertificate)) { certificateValues.AddItem(X509CertificateStructure.GetInstance(((Asn1Sequence)Asn1Object.FromByteArray (c.GetCertificate().GetEncoded())))); } } foreach (X509Crl relatedcrl in validationContext.GetNeededCRL()) { crlValues.AddItem(CertificateList.GetInstance((Asn1Sequence)Asn1Object.FromByteArray(((X509Crl )relatedcrl).GetEncoded()))); } foreach (BasicOcspResp relatedocspresp in validationContext.GetNeededOCSPResp()) { ocspValues.AddItem((BasicOcspResponse.GetInstance((Asn1Sequence)Asn1Object.FromByteArray( relatedocspresp.GetEncoded())))); } CertificateList[] crlValuesArray = new CertificateList[crlValues.Count]; BasicOcspResponse[] ocspValuesArray = new BasicOcspResponse[ocspValues.Count]; RevocationValues revocationValues = new RevocationValues(Sharpen.Collections.ToArray (crlValues, crlValuesArray), Sharpen.Collections.ToArray(ocspValues, ocspValuesArray ), null); //unsignedAttrs.Put(PkcsObjectIdentifiers.IdAAEtsRevocationValues, new Attribute unsignedAttrs.Add(PkcsObjectIdentifiers.IdAAEtsRevocationValues, new BcCms.Attribute (PkcsObjectIdentifiers.IdAAEtsRevocationValues, new DerSet(revocationValues)) ); X509CertificateStructure[] certValuesArray = new X509CertificateStructure[certificateValues .Count]; //unsignedAttrs.Put(PkcsObjectIdentifiers.IdAAEtsCertValues, new Attribute(PkcsObjectIdentifiers.IdAAEtsCertValues, new DerSet(new DerSequence(Sharpen.Collections.ToArray(certificateValues unsignedAttrs.Add(PkcsObjectIdentifiers.IdAAEtsCertValues, new BcCms.Attribute(PkcsObjectIdentifiers.IdAAEtsCertValues, new DerSet(new DerSequence(Sharpen.Collections.ToArray(certificateValues , certValuesArray))))); } catch (CertificateEncodingException e) { throw new RuntimeException(e); } catch (CrlException e) { throw new RuntimeException(e); } return unsignedAttrs; }
public override IList<AdvancedSignature> GetSignatures() { IList<AdvancedSignature> infos = new AList<AdvancedSignature>(); foreach (object o in this.cmsSignedData.GetSignerInfos().GetSigners()) { SignerInformation i = (SignerInformation)o; CAdESSignature info = new CAdESSignature(this.cmsSignedData, i.SignerID); infos.AddItem(info); } return infos; }
/// <summary>Update this remote's definition within the configuration.</summary> /// <remarks>Update this remote's definition within the configuration.</remarks> /// <param name="rc">the configuration file to store ourselves into.</param> public virtual void Update(Config rc) { IList <string> vlst = new AList <string>(); vlst.Clear(); foreach (URIish u in URIs) { vlst.AddItem(u.ToPrivateString()); } rc.SetStringList(SECTION, Name, KEY_URL, vlst); vlst.Clear(); foreach (URIish u_1 in PushURIs) { vlst.AddItem(u_1.ToPrivateString()); } rc.SetStringList(SECTION, Name, KEY_PUSHURL, vlst); vlst.Clear(); foreach (RefSpec u_2 in FetchRefSpecs) { vlst.AddItem(u_2.ToString()); } rc.SetStringList(SECTION, Name, KEY_FETCH, vlst); vlst.Clear(); foreach (RefSpec u_3 in PushRefSpecs) { vlst.AddItem(u_3.ToString()); } rc.SetStringList(SECTION, Name, KEY_PUSH, vlst); Set(rc, KEY_UPLOADPACK, UploadPack, DEFAULT_UPLOAD_PACK); Set(rc, KEY_RECEIVEPACK, ReceivePack, DEFAULT_RECEIVE_PACK); Set(rc, KEY_TAGOPT, TagOpt.Option(), NGit.Transport.TagOpt.AUTO_FOLLOW.Option()); Set(rc, KEY_MIRROR, mirror, DEFAULT_MIRROR); Set(rc, KEY_TIMEOUT, timeout, 0); if (!oldName.Equals(name)) { rc.UnsetSection(SECTION, oldName); oldName = name; } }
/// <summary> /// Interpret the ChildrenDiff and generate a list of /// <see cref="Org.Apache.Hadoop.Hdfs.Protocol.SnapshotDiffReport.DiffReportEntry"/> /// . /// </summary> /// <param name="dirDiff">The ChildrenDiff.</param> /// <param name="parentPath">The relative path of the parent.</param> /// <param name="fromEarlier"> /// True indicates /// <c>diff=later-earlier</c> /// , /// False indicates /// <c>diff=earlier-later</c> /// </param> /// <param name="renameMap">A map containing information about rename operations.</param> /// <returns> /// A list of /// <see cref="Org.Apache.Hadoop.Hdfs.Protocol.SnapshotDiffReport.DiffReportEntry"/> /// as the diff report. /// </returns> private IList <SnapshotDiffReport.DiffReportEntry> GenerateReport(DirectoryWithSnapshotFeature.ChildrenDiff dirDiff, byte[][] parentPath, bool fromEarlier, IDictionary <long, SnapshotDiffInfo.RenameEntry > renameMap) { IList <SnapshotDiffReport.DiffReportEntry> list = new AList <SnapshotDiffReport.DiffReportEntry >(); IList <INode> created = dirDiff.GetList(Diff.ListType.Created); IList <INode> deleted = dirDiff.GetList(Diff.ListType.Deleted); byte[][] fullPath = new byte[parentPath.Length + 1][]; System.Array.Copy(parentPath, 0, fullPath, 0, parentPath.Length); foreach (INode cnode in created) { SnapshotDiffInfo.RenameEntry entry = renameMap[cnode.GetId()]; if (entry == null || !entry.IsRename()) { fullPath[fullPath.Length - 1] = cnode.GetLocalNameBytes(); list.AddItem(new SnapshotDiffReport.DiffReportEntry(fromEarlier ? SnapshotDiffReport.DiffType .Create : SnapshotDiffReport.DiffType.Delete, fullPath)); } } foreach (INode dnode in deleted) { SnapshotDiffInfo.RenameEntry entry = renameMap[dnode.GetId()]; if (entry != null && entry.IsRename()) { list.AddItem(new SnapshotDiffReport.DiffReportEntry(SnapshotDiffReport.DiffType.Rename , fromEarlier ? entry.GetSourcePath() : entry.GetTargetPath(), fromEarlier ? entry .GetTargetPath() : entry.GetSourcePath())); } else { fullPath[fullPath.Length - 1] = dnode.GetLocalNameBytes(); list.AddItem(new SnapshotDiffReport.DiffReportEntry(fromEarlier ? SnapshotDiffReport.DiffType .Delete : SnapshotDiffReport.DiffType.Create, fullPath)); } } return(list); }
/// <exception cref="System.IO.IOException"/> private ICollection <BlockRecoveryCommand.RecoveringBlock> InitRecoveringBlocks() { ICollection <BlockRecoveryCommand.RecoveringBlock> blocks = new AList <BlockRecoveryCommand.RecoveringBlock >(1); DatanodeInfo mockOtherDN = DFSTestUtil.GetLocalDatanodeInfo(); DatanodeInfo[] locs = new DatanodeInfo[] { new DatanodeInfo(dn.GetDNRegistrationForBP (block.GetBlockPoolId())), mockOtherDN }; BlockRecoveryCommand.RecoveringBlock rBlock = new BlockRecoveryCommand.RecoveringBlock (block, locs, RecoveryId); blocks.AddItem(rBlock); return(blocks); }
private static IList <DiffEntry> CompactDstList(IList <DiffEntry> @in) { AList <DiffEntry> r = new AList <DiffEntry>(@in.Count); foreach (DiffEntry e in @in) { if (e != null) { r.AddItem(e); } } return(r); }
private static IList <DiffEntry> CompactSrcList(IList <DiffEntry> @in) { AList <DiffEntry> r = new AList <DiffEntry>(@in.Count); foreach (DiffEntry e in @in) { if (e.changeType == DiffEntry.ChangeType.DELETE) { r.AddItem(e); } } return(r); }
/// <summary>Returns the CRLs in the context which concern the provided certificate.</summary> /// <remarks> /// Returns the CRLs in the context which concern the provided certificate. It can happen there are more than one, /// even though this is unlikely. /// </remarks> /// <param name="cert">the X509 certificate</param> /// <returns>the list of CRLs related to the certificate</returns> public virtual IList <X509Crl> GetRelatedCRLs(CertificateAndContext cert) { IList <X509Crl> crls = new AList <X509Crl>(); foreach (X509Crl crl in this.neededCRL) { if (ConcernsCertificate(crl, cert)) { crls.AddItem(crl); } } return(crls); }
/// <returns> /// return an array of the unique objects. The return value is /// expected to be used by the a combiner. /// </returns> public virtual AList <object> GetCombinerOutput() { object key = null; IEnumerator <object> iter = uniqItems.Keys.GetEnumerator(); AList <object> retv = new AList <object>(); while (iter.HasNext()) { key = iter.Next(); retv.AddItem(key); } return(retv); }
public static IList <string> GetProxyHostsAndPortsForAmFilter(Configuration conf) { IList <string> addrs = new AList <string>(); string proxyAddr = conf.Get(YarnConfiguration.ProxyAddress); // If PROXY_ADDRESS isn't set, fallback to RM_WEBAPP(_HTTPS)_ADDRESS // There could be multiple if using RM HA if (proxyAddr == null || proxyAddr.IsEmpty()) { // If RM HA is enabled, try getting those addresses if (HAUtil.IsHAEnabled(conf)) { IList <string> haAddrs = RMHAUtils.GetRMHAWebappAddresses(new YarnConfiguration(conf )); foreach (string addr in haAddrs) { try { IPEndPoint socketAddr = NetUtils.CreateSocketAddr(addr); addrs.AddItem(GetResolvedAddress(socketAddr)); } catch (ArgumentException) { } } } // skip if can't resolve // If couldn't resolve any of the addresses or not using RM HA, fallback if (addrs.IsEmpty()) { addrs.AddItem(GetResolvedRMWebAppURLWithoutScheme(conf)); } } else { addrs.AddItem(proxyAddr); } return(addrs); }
/// <exception cref="System.Exception"/> public virtual void TestDataDirValidation() { DataNode.DataNodeDiskChecker diskChecker = Org.Mockito.Mockito.Mock <DataNode.DataNodeDiskChecker >(); Org.Mockito.Mockito.DoThrow(new IOException()).DoThrow(new IOException()).DoNothing ().When(diskChecker).CheckDir(Any <LocalFileSystem>(), Any <Path>()); LocalFileSystem fs = Org.Mockito.Mockito.Mock <LocalFileSystem>(); AbstractList <StorageLocation> locations = new AList <StorageLocation>(); locations.AddItem(StorageLocation.Parse("file:/p1/")); locations.AddItem(StorageLocation.Parse("file:/p2/")); locations.AddItem(StorageLocation.Parse("file:/p3/")); IList <StorageLocation> checkedLocations = DataNode.CheckStorageLocations(locations , fs, diskChecker); NUnit.Framework.Assert.AreEqual("number of valid data dirs", 1, checkedLocations. Count); string validDir = checkedLocations.GetEnumerator().Next().GetFile().GetPath(); Assert.AssertThat("p3 should be valid", new FilePath("/p3/").GetPath(), CoreMatchers.Is (validDir)); }
public override IList <X509Certificate> GetCertificates() { IList <X509Certificate> list = new AList <X509Certificate>(); XmlNodeList nodes; nodes = XmlUtils.GetNodeList(signatureElement, "//ds:Object/xades:QualifyingProperties/xades:UnsignedProperties/xades:UnsignedSignatureProperties/xades:CertificateValues/xades:EncapsulatedX509Certificate"); foreach (XmlNode node in nodes) { byte[] derEncoded = Base64.Decode( System.Text.Encoding.ASCII.GetBytes(node.InnerText)); X509Certificate cert = new X509CertificateParser().ReadCertificate(derEncoded); if (!list.Contains(cert)) { list.AddItem(cert); } } if (!onlyExtended) { nodes = XmlUtils.GetNodeList(signatureElement, "//ds:KeyInfo/ds:X509Data/ds:X509Certificate"); foreach (XmlNode node in nodes) { byte[] derEncoded = Base64.Decode( System.Text.Encoding.ASCII.GetBytes(node.InnerText)); X509Certificate cert = new X509CertificateParser().ReadCertificate(derEncoded); if (!list.Contains(cert)) { list.AddItem(cert); } } } return(list); }
> GetProtocolImplMap(RPC.RpcKind rpcKind) { if (protocolImplMapArray.Count == 0) { // initialize for all rpc kinds for (int i = 0; i <= RPC.RpcKind.MaxIndex; ++i) { protocolImplMapArray.AddItem(new Dictionary <RPC.Server.ProtoNameVer, RPC.Server.ProtoClassProtoImpl >(10)); } } return(protocolImplMapArray[(int)(rpcKind)]); }
/// <summary>Retrieve all the qualifiers for which the corresponding condition evaluate to true. /// </summary> /// <remarks>Retrieve all the qualifiers for which the corresponding condition evaluate to true. /// </remarks> /// <param name="cert"></param> /// <returns></returns> public virtual IList <string> GetQualifiers(CertificateAndContext cert) { IList <string> list = new AList <string>(); foreach (KeyValuePair <string, Condition> e in qualifiersAndConditions.EntrySet()) { if (e.Value.Check(cert)) { list.AddItem(e.Key); } } return(list); }
/// <summary> /// Logically splits the set of input files for the job, splits N lines /// of the input as one split. /// </summary> /// <seealso cref="Org.Apache.Hadoop.Mapred.FileInputFormat{K, V}.GetSplits(Org.Apache.Hadoop.Mapred.JobConf, int) /// "/> /// <exception cref="System.IO.IOException"/> public override InputSplit[] GetSplits(JobConf job, int numSplits) { AList <FileSplit> splits = new AList <FileSplit>(); foreach (FileStatus status in ListStatus(job)) { foreach (FileSplit split in NLineInputFormat.GetSplitsForFile(status, job, N)) { splits.AddItem(new FileSplit(split)); } } return(Sharpen.Collections.ToArray(splits, new FileSplit[splits.Count])); }
public virtual SnapshottableDirectoryStatus.Bean[] GetSnapshottableDirectories() { // SnapshotStatsMXBean IList <SnapshottableDirectoryStatus.Bean> beans = new AList <SnapshottableDirectoryStatus.Bean >(); foreach (INodeDirectory d in GetSnapshottableDirs()) { beans.AddItem(ToBean(d)); } return(Sharpen.Collections.ToArray(beans, new SnapshottableDirectoryStatus.Bean[beans .Count])); }
/// <exception cref="NGit.Errors.TransportException"></exception> private ICollection <Ref> ExpandAutoFollowTags() { ICollection <Ref> additionalTags = new AList <Ref>(); IDictionary <string, Ref> haveRefs = transport.local.GetAllRefs(); foreach (Ref r in conn.GetRefs()) { if (!IsTag(r)) { continue; } if (r.GetPeeledObjectId() == null) { additionalTags.AddItem(r); continue; } Ref local = haveRefs.Get(r.GetName()); if (local != null) { if (!r.GetObjectId().Equals(local.GetObjectId())) { WantTag(r); } } else { if (askFor.ContainsKey(r.GetPeeledObjectId()) || transport.local.HasObject(r.GetPeeledObjectId ())) { WantTag(r); } else { additionalTags.AddItem(r); } } } return(additionalTags); }
/// <summary> /// Parses a string representation of an ACL spec into a list of AclEntry /// objects. /// </summary> /// <remarks> /// Parses a string representation of an ACL spec into a list of AclEntry /// objects. Example: "user::rwx,user:foo:rw-,group::r--,other::---" /// </remarks> /// <param name="aclSpec">String representation of an ACL spec.</param> /// <param name="includePermission"> /// for setAcl operations this will be true. i.e. AclSpec should /// include permissions.<br /> /// But for removeAcl operation it will be false. i.e. AclSpec should /// not contain permissions.<br /> /// Example: "user:foo,group:bar" /// </param> /// <returns> /// Returns list of /// <see cref="AclEntry"/> /// parsed /// </returns> public static IList <AclEntry> ParseAclSpec(string aclSpec, bool includePermission ) { IList <AclEntry> aclEntries = new AList <AclEntry>(); ICollection <string> aclStrings = StringUtils.GetStringCollection(aclSpec, ","); foreach (string aclStr in aclStrings) { AclEntry aclEntry = ParseAclEntry(aclStr, includePermission); aclEntries.AddItem(aclEntry); } return(aclEntries); }
public virtual IList <AdvancedSignature> GetCounterSignatures() { IList <AdvancedSignature> counterSigs = new AList <AdvancedSignature>(); foreach (object o in this.signerInformation.GetCounterSignatures().GetSigners()) { SignerInformation i = (SignerInformation)o; EU.Europa.EC.Markt.Dss.Validation.Cades.CAdESSignature info = new EU.Europa.EC.Markt.Dss.Validation.Cades.CAdESSignature (this.cmsSignedData, i.SignerID); counterSigs.AddItem(info); } return(counterSigs); }
/// <summary> /// Generate the requested number of file splits, with the filename /// set to the filename of the output file. /// </summary> /// <exception cref="System.IO.IOException"/> public override IList <InputSplit> GetSplits(JobContext job) { IList <InputSplit> result = new AList <InputSplit>(); Path outDir = FileOutputFormat.GetOutputPath(job); int numSplits = job.GetConfiguration().GetInt(MRJobConfig.NumMaps, 1); for (int i = 0; i < numSplits; ++i) { result.AddItem(new FileSplit(new Path(outDir, "dummy-split-" + i), 0, 1, (string[] )null)); } return(result); }
private IList <string> GetProcessed(IList <string> inputs, IList <string> badRecs) { IList <string> processed = new AList <string>(); foreach (string input in inputs) { if (!badRecs.Contains(input)) { processed.AddItem(input); } } return(processed); }
/// <summary>Dump a list of currently running jobs</summary> /// <exception cref="System.IO.IOException"/> /// <exception cref="System.Exception"/> private void ListJobs(Cluster cluster) { IList <JobStatus> runningJobs = new AList <JobStatus>(); foreach (JobStatus job in cluster.GetAllJobStatuses()) { if (!job.IsJobComplete()) { runningJobs.AddItem(job); } } DisplayJobList(Sharpen.Collections.ToArray(runningJobs, new JobStatus[0])); }
private void AddLocalRequestsToProto() { MaybeInitBuilder(); builder.ClearStartContainerRequest(); IList <YarnServiceProtos.StartContainerRequestProto> protoList = new AList <YarnServiceProtos.StartContainerRequestProto >(); foreach (StartContainerRequest r in this.requests) { protoList.AddItem(ConvertToProtoFormat(r)); } builder.AddAllStartContainerRequest(protoList); }
/// <summary>Get an RPC proxy for each NN in an HA nameservice.</summary> /// <remarks> /// Get an RPC proxy for each NN in an HA nameservice. Used when a given RPC /// call should be made on every NN in an HA nameservice, not just the active. /// </remarks> /// <param name="conf">configuration</param> /// <param name="nsId">the nameservice to get all of the proxies for.</param> /// <returns>a list of RPC proxies for each NN in the nameservice.</returns> /// <exception cref="System.IO.IOException">in the event of error.</exception> public static IList <ClientProtocol> GetProxiesForAllNameNodesInNameservice(Configuration conf, string nsId) { IList <NameNodeProxies.ProxyAndInfo <ClientProtocol> > proxies = GetProxiesForAllNameNodesInNameservice <ClientProtocol>(conf, nsId); IList <ClientProtocol> namenodes = new AList <ClientProtocol>(proxies.Count); foreach (NameNodeProxies.ProxyAndInfo <ClientProtocol> proxy in proxies) { namenodes.AddItem(proxy.GetProxy()); } return(namenodes); }
/// <summary>Load the deleted list in a DirectoryDiff</summary> /// <exception cref="System.IO.IOException"/> private IList <INode> LoadDeletedList(IList <INodeReference> refList, InputStream @in , INodeDirectory dir, IList <long> deletedNodes, IList <int> deletedRefNodes) { IList <INode> dlist = new AList <INode>(deletedRefNodes.Count + deletedNodes.Count); // load non-reference inodes foreach (long deletedId in deletedNodes) { INode deleted = fsDir.GetInode(deletedId); dlist.AddItem(deleted); AddToDeletedList(deleted, dir); } // load reference nodes in the deleted list foreach (int refId in deletedRefNodes) { INodeReference deletedRef = refList[refId]; dlist.AddItem(deletedRef); AddToDeletedList(deletedRef, dir); } dlist.Sort(new _IComparer_303()); return(dlist); }
public static string[] GetAllMatches(string input) { Sharpen.Pattern p = Sharpen.Pattern.Compile("([0-9]*\\.[0-9]+|[0-9]+|[a-zA-Z]+|[^\\w\\s])" ); Matcher m = p.Matcher(input); AList<string> matches = new AList<string>(); while (m.Find()) { matches.AddItem(m.Group()); } string[] matchArr = new string[matches.Count]; return Sharpen.Collections.ToArray(matches, matchArr); }
/// <summary>Divides the given string into lines.</summary> /// <remarks>Divides the given string into lines.</remarks> /// <param name="s">the string to read</param> /// <returns>the string divided into lines</returns> /// <since>2.0</since> public static IList <string> ReadLines(string s) { IList <string> l = new AList <string>(); StringBuilder sb = new StringBuilder(); for (int i = 0; i < s.Length; i++) { char c = s[i]; if (c == '\n') { l.AddItem(sb.ToString()); sb.Length = 0; continue; } if (c == '\r') { if (i + 1 < s.Length) { c = s[++i]; l.AddItem(sb.ToString()); sb.Length = 0; if (c != '\n') { sb.Append(c); } continue; } else { // EOF l.AddItem(sb.ToString()); break; } } sb.Append(c); } l.AddItem(sb.ToString()); return(l); }
/// <summary>Translate an absolute path into a list of path components.</summary> /// <remarks> /// Translate an absolute path into a list of path components. /// We merge double slashes into a single slash here. /// POSIX root path, i.e. '/', does not get an entry in the list. /// </remarks> /// <exception cref="System.IO.IOException"/> private static IList <string> GetPathComponents(string path) { AList <string> ret = new AList <string>(); foreach (string component in path.Split(Path.Separator)) { if (!component.IsEmpty()) { ret.AddItem(component); } } return(ret); }
/// <exception cref="System.IO.IOException"/> public virtual void TestChangeVolumeWithRunningCheckDirs() { RoundRobinVolumeChoosingPolicy <FsVolumeImpl> blockChooser = new RoundRobinVolumeChoosingPolicy <FsVolumeImpl>(); conf.SetLong(DFSConfigKeys.DfsDatanodeScanPeriodHoursKey, -1); BlockScanner blockScanner = new BlockScanner(datanode, conf); FsVolumeList volumeList = new FsVolumeList(Sharpen.Collections.EmptyList <VolumeFailureInfo >(), blockScanner, blockChooser); IList <FsVolumeImpl> oldVolumes = new AList <FsVolumeImpl>(); // Initialize FsVolumeList with 5 mock volumes. int NumVolumes = 5; for (int i = 0; i < NumVolumes; i++) { FsVolumeImpl volume = Org.Mockito.Mockito.Mock <FsVolumeImpl>(); oldVolumes.AddItem(volume); Org.Mockito.Mockito.When(volume.GetBasePath()).ThenReturn("data" + i); FsVolumeReference @ref = Org.Mockito.Mockito.Mock <FsVolumeReference>(); Org.Mockito.Mockito.When(@ref.GetVolume()).ThenReturn(volume); volumeList.AddVolume(@ref); } // When call checkDirs() on the 2nd volume, anther "thread" removes the 5th // volume and add another volume. It does not affect checkDirs() running. FsVolumeImpl newVolume = Org.Mockito.Mockito.Mock <FsVolumeImpl>(); FsVolumeReference newRef = Org.Mockito.Mockito.Mock <FsVolumeReference>(); Org.Mockito.Mockito.When(newRef.GetVolume()).ThenReturn(newVolume); Org.Mockito.Mockito.When(newVolume.GetBasePath()).ThenReturn("data4"); FsVolumeImpl blockedVolume = volumeList.GetVolumes()[1]; Org.Mockito.Mockito.DoAnswer(new _Answer_295(volumeList, newRef)).When(blockedVolume ).CheckDirs(); FsVolumeImpl brokenVolume = volumeList.GetVolumes()[2]; Org.Mockito.Mockito.DoThrow(new DiskChecker.DiskErrorException("broken")).When(brokenVolume ).CheckDirs(); volumeList.CheckDirs(); // Since FsVolumeImpl#checkDirs() get a snapshot of the list of volumes // before running removeVolume(), it is supposed to run checkDirs() on all // the old volumes. foreach (FsVolumeImpl volume_1 in oldVolumes) { Org.Mockito.Mockito.Verify(volume_1).CheckDirs(); } // New volume is not visible to checkDirs() process. Org.Mockito.Mockito.Verify(newVolume, Org.Mockito.Mockito.Never()).CheckDirs(); NUnit.Framework.Assert.IsTrue(volumeList.GetVolumes().Contains(newVolume)); NUnit.Framework.Assert.IsFalse(volumeList.GetVolumes().Contains(brokenVolume)); NUnit.Framework.Assert.AreEqual(NumVolumes - 1, volumeList.GetVolumes().Count); }
public virtual void TestDatabase() { Send("PUT", "/database", Status.Created, null); IDictionary entries = new Dictionary <string, IDictionary <string, object> >(); entries.Put("results", new AList <object>()); entries.Put("last_seq", 0); Send("GET", "/database/_changes?feed=normal&heartbeat=300000&style=all_docs", Status .Ok, entries); IDictionary <string, object> dbInfo = (IDictionary <string, object>)Send("GET", "/database" , Status.Ok, null); NUnit.Framework.Assert.AreEqual(6, dbInfo.Count); NUnit.Framework.Assert.AreEqual(0, dbInfo.Get("doc_count")); NUnit.Framework.Assert.AreEqual(0, dbInfo.Get("update_seq")); NUnit.Framework.Assert.IsTrue((int)dbInfo.Get("disk_size") > 8000); NUnit.Framework.Assert.AreEqual("database", dbInfo.Get("db_name")); NUnit.Framework.Assert.IsTrue(Runtime.CurrentTimeMillis() * 1000 > (long)dbInfo.Get ("instance_start_time")); NUnit.Framework.Assert.IsTrue(dbInfo.ContainsKey("db_uuid")); Send("PUT", "/database", Status.PreconditionFailed, null); Send("PUT", "/database2", Status.Created, null); IList <string> allDbs = new AList <string>(); allDbs.AddItem("cblite-test"); allDbs.AddItem("database"); allDbs.AddItem("database2"); Send("GET", "/_all_dbs", Status.Ok, allDbs); dbInfo = (IDictionary <string, object>)Send("GET", "/database2", Status.Ok, null); NUnit.Framework.Assert.AreEqual("database2", dbInfo.Get("db_name")); Send("DELETE", "/database2", Status.Ok, null); allDbs.Remove("database2"); Send("GET", "/_all_dbs", Status.Ok, allDbs); Send("PUT", "/database%2Fwith%2Fslashes", Status.Created, null); dbInfo = (IDictionary <string, object>)Send("GET", "/database%2Fwith%2Fslashes", Status .Ok, null); NUnit.Framework.Assert.AreEqual("database/with/slashes", dbInfo.Get("db_name")); }
/// <exception cref="System.IO.IOException"/> public override InputSplit[] GetSplits(JobConf conf, int numSplits) { AList <InputSplit> result = new AList <InputSplit>(); FileSystem local = FileSystem.GetLocal(conf); foreach (Path dir in GetInputPaths(conf)) { foreach (FileStatus file in local.ListStatus(dir)) { result.AddItem(new WordCountInputFormat.WordCountInputSplit(file.GetPath())); } } return(Sharpen.Collections.ToArray(result, new InputSplit[result.Count])); }
internal virtual ICollection <string> GetVolumesLowOnSpace() { if (Log.IsDebugEnabled()) { Log.Debug("Going to check the following volumes disk space: " + volumes); } ICollection <string> lowVolumes = new AList <string>(); foreach (NameNodeResourceChecker.CheckedVolume volume in volumes.Values) { lowVolumes.AddItem(volume.GetVolume()); } return(lowVolumes); }
/// <summary> /// Gets all the declared methods of a class including methods declared in /// superclasses. /// </summary> public static IList <MethodInfo> GetDeclaredMethodsIncludingInherited(Type clazz) { IList <MethodInfo> methods = new AList <MethodInfo>(); while (clazz != null) { foreach (MethodInfo method in Runtime.GetDeclaredMethods(clazz)) { methods.AddItem(method); } clazz = clazz.BaseType; } return(methods); }
public static Query GetQueryById(Database database, string userId) { View view = database.GetView(ByIdViewName); if (view.GetMap() == null) { Mapper map = new _Mapper_52(); view.SetMap(map, null); } Query query = view.CreateQuery(); IList<object> keys = new AList<object>(); keys.AddItem(userId); query.SetKeys(keys); return query; }
/// <exception cref="Sharpen.SAXException"></exception> public bool Start(NBoilerpipeContentHandler instance, string localName, HtmlAttributeCollection atts) { IList<string> labels = new AList<string> (5); labels.AddItem (DefaultLabels.MARKUP_PREFIX + localName); string classVal = atts ["class"].Value; if (classVal != null && classVal.Length > 0) { classVal = PAT_NUM.Matcher (classVal).ReplaceAll ("#"); classVal = classVal.Trim (); string[] vals = classVal.Split ("[ ]+"); labels.AddItem (DefaultLabels.MARKUP_PREFIX + "." + classVal.Replace (' ', '.')); if (vals.Length > 1) { foreach (string s in vals) { labels.AddItem (DefaultLabels.MARKUP_PREFIX + "." + s); } } } var att = atts["id"]; var id = ( atts !=null) ? att.Name : ""; if (id != null && id.Length > 0) { id = PAT_NUM.Matcher (id).ReplaceAll ("#"); labels.AddItem (DefaultLabels.MARKUP_PREFIX + "#" + id); } ICollection<string> ancestors = GetAncestorLabels (); IList<string> labelsWithAncestors = new AList<string> ((ancestors.Count + 1) * labels .Count); foreach (string l in labels) { foreach (string an in ancestors) { labelsWithAncestors.AddItem (an); labelsWithAncestors.AddItem (an + " " + l); } labelsWithAncestors.AddItem (l); } instance.AddLabelAction (new LabelAction (Sharpen.Collections.ToArray (labelsWithAncestors , new string[labelsWithAncestors.Count]))); labelStack.AddItem (labels); return isBlockLevel; }
public IList<CertificateAndContext> GetCertificateBySubjectName(X509Name subjectName ) { IList<CertificateAndContext> list = new AList<CertificateAndContext>(); foreach (X509Certificate cert in GetCertificates()) { if (subjectName.Equals(cert.SubjectDN)) { CertificateAndContext cc = new CertificateAndContext(cert); cc.SetCertificateSource(sourceType); list.AddItem(cc); } } return list; }
/// <exception cref="System.Exception"></exception> public virtual void TestJsonArray() { IList<object> array = new AList<object>(); array.AddItem("01234567890"); array.AddItem("bar"); array.AddItem(5); array.AddItem(3.5); array.AddItem(true); array.AddItem(new DateTime().ToString()); ObjectWriter mapper = new ObjectWriter(); byte[] json = mapper.WriteValueAsBytes(array); JsonDocument jsdoc = new JsonDocument(json); NUnit.Framework.Assert.AreEqual(array, jsdoc.JsonObject()); }
/// <exception cref="System.IO.IOException"></exception> public virtual Document ExtendSignatures(Document document, Document originalData , SignatureParameters parameters) { try { CmsSignedData signedData = new CmsSignedData(document.OpenStream()); SignerInformationStore signerStore = signedData.GetSignerInfos(); AList<SignerInformation> siArray = new AList<SignerInformation>(); foreach (SignerInformation si in signerStore.GetSigners()) { try { //jbonilla - Hack para evitar errores cuando una firma ya ha sido extendida. //Se asume que sólo se extiende las firmas desde BES. //TODO jbonilla - Se debería validar hasta qué punto se extendió (BES, T, C, X, XL). if(si.UnsignedAttributes.Count == 0) { siArray.AddItem(ExtendCMSSignature(signedData, si, parameters, originalData)); } else { LOG.Error("Already extended?"); siArray.AddItem(si); } } catch (IOException) { LOG.Error("Exception when extending signature"); siArray.AddItem(si); } } SignerInformationStore newSignerStore = new SignerInformationStore(siArray); CmsSignedData extended = CmsSignedData.ReplaceSigners(signedData, newSignerStore); return new InMemoryDocument(extended.GetEncoded()); } catch (CmsException) { throw new IOException("Cannot parse CMS data"); } }
public override IList<Couchbase.Lite.SavedRevision> GetRevisionHistory() { IList<Couchbase.Lite.SavedRevision> revisions = new AList<Couchbase.Lite.SavedRevision >(); IList<RevisionInternal> internalRevisions = GetDatabase().GetRevisionHistory(revisionInternal ); foreach (RevisionInternal internalRevision in internalRevisions) { if (internalRevision.GetRevId().Equals(GetId())) { revisions.AddItem(this); } else { Couchbase.Lite.SavedRevision revision = document.GetRevisionFromRev(internalRevision ); revisions.AddItem(revision); } } Sharpen.Collections.Reverse(revisions); return Sharpen.Collections.UnmodifiableList(revisions); }
public virtual void TestServer() { IDictionary<string, object> responseBody = new Dictionary<string, object>(); responseBody["CBLite"] = "Welcome"; responseBody["couchdb"] = "Welcome"; responseBody.Put("version", Couchbase.Lite.Router.Router.GetVersionString()); Send("GET", "/", Status.Ok, responseBody); IDictionary<string, object> session = new Dictionary<string, object>(); IDictionary<string, object> userCtx = new Dictionary<string, object>(); IList<string> roles = new AList<string>(); roles.AddItem("_admin"); session["ok"] = true; userCtx["name"] = null; userCtx["roles"] = roles; session["userCtx"] = userCtx; Send("GET", "/_session", Status.Ok, session); IList<string> allDbs = new AList<string>(); allDbs.AddItem("cblite-test"); Send("GET", "/_all_dbs", Status.Ok, allDbs); Send("GET", "/non-existant", Status.NotFound, null); Send("GET", "/BadName", Status.BadRequest, null); Send("PUT", "/", Status.BadRequest, null); Send("POST", "/", Status.BadRequest, null); }
public override IList<X509Certificate> GetCertificates() { IList<X509Certificate> certs = new AList<X509Certificate>(); try { //foreach (X509Certificate c in ocspResp.GetCerts(null)) foreach (X509Certificate c in ocspResp.GetCerts()) { LOG.Info(c.SubjectDN + " issued by " + c.IssuerDN + " serial number " + c.SerialNumber); certs.AddItem(c); } } catch (OcspException) { throw new EncodingException(EncodingException.MSG.OCSP_CANNOT_BE_READ); } /*catch (NoSuchProviderException e) { // Provider (BouncyCastle) not found. Should never happens. throw new RuntimeException(e); }*/ return certs; }
/// <summary>Filter a list of commands according to result.</summary> /// <remarks>Filter a list of commands according to result.</remarks> /// <param name="commands">commands to filter.</param> /// <param name="want">desired status to filter by.</param> /// <returns> /// a copy of the command list containing only those commands with /// the desired status. /// </returns> /// <since>2.0</since> public static IList<NGit.Transport.ReceiveCommand> Filter(IList<NGit.Transport.ReceiveCommand > commands, ReceiveCommand.Result want) { IList<NGit.Transport.ReceiveCommand> r = new AList<NGit.Transport.ReceiveCommand> (commands.Count); foreach (NGit.Transport.ReceiveCommand cmd in commands) { if (cmd.GetResult() == want) { r.AddItem(cmd); } } return r; }
/// <exception cref="Kirikiri.Tjs2.TJSException"></exception> /// <exception cref="Kirikiri.Tjs2.VariantException"></exception> public virtual void AssignStructure(Dispatch2 dsp, AList<Dispatch2> stack) { // assign structured data from dsp ArrayNI arrayni = (ArrayNI)dsp.GetNativeInstance(ArrayClass.ClassID); if (arrayni != null) { // copy from array stack.AddItem(dsp); try { mItems.Clear(); int count = arrayni.mItems.Count; for (int i = 0; i < count; i++) { Variant v = arrayni.mItems[i]; if (v.IsObject()) { // object Dispatch2 dsp1 = v.AsObject(); // determin dsp's object type //DictionaryNI dicni = null; //ArrayNI arrayni1 = null; if (dsp1 != null && dsp1.GetNativeInstance(DictionaryClass.ClassID) != null) { //dicni = (DictionaryNI)ni.mValue; // dictionary bool objrec = false; int scount = stack.Count; for (int j = 0; j < scount; j++) { Dispatch2 d = stack[j]; if (d == dsp1) { // object recursion detected objrec = true; break; } } if (objrec) { mItems.AddItem(new Variant()); } else { // becomes null Dispatch2 newobj = TJS.CreateDictionaryObject(); mItems.AddItem(new Variant(newobj, newobj)); DictionaryNI newni; if ((newni = (DictionaryNI)newobj.GetNativeInstance(DictionaryClass.ClassID)) != null) { newni.AssignStructure(dsp1, stack); } } } else { if (dsp1 != null && dsp1.GetNativeInstance(ArrayClass.ClassID) != null) { // array bool objrec = false; int scount = stack.Count; for (int j = 0; j < scount; j++) { Dispatch2 d = stack[j]; if (d == dsp1) { // object recursion detected objrec = true; break; } } if (objrec) { mItems.AddItem(new Variant()); } else { // becomes null Dispatch2 newobj = TJS.CreateArrayObject(); mItems.AddItem(new Variant(newobj, newobj)); ArrayNI newni; if ((newni = (ArrayNI)newobj.GetNativeInstance(ArrayClass.ClassID)) != null) { newni.AssignStructure(dsp1, stack); } } } else { // other object types mItems.AddItem(v); } } } else { // others mItems.AddItem(v); } } } finally { stack.Remove(stack.Count - 1); } } else { throw new TJSException(Error.SpecifyDicOrArray); } }
/// <summary>Construct the merge commit message.</summary> /// <remarks>Construct the merge commit message.</remarks> /// <param name="refsToMerge">the refs which will be merged</param> /// <param name="target">the branch ref which will be merged into</param> /// <returns>merge commit message</returns> public virtual string Format(IList<Ref> refsToMerge, Ref target) { StringBuilder sb = new StringBuilder(); sb.Append("Merge "); IList<string> branches = new AList<string>(); IList<string> remoteBranches = new AList<string>(); IList<string> tags = new AList<string>(); IList<string> commits = new AList<string>(); IList<string> others = new AList<string>(); foreach (Ref @ref in refsToMerge) { if (@ref.GetName().StartsWith(Constants.R_HEADS)) { branches.AddItem("'" + Repository.ShortenRefName(@ref.GetName()) + "'"); } else { if (@ref.GetName().StartsWith(Constants.R_REMOTES)) { remoteBranches.AddItem("'" + Repository.ShortenRefName(@ref.GetName()) + "'"); } else { if (@ref.GetName().StartsWith(Constants.R_TAGS)) { tags.AddItem("'" + Repository.ShortenRefName(@ref.GetName()) + "'"); } else { if (@ref.GetName().Equals(@ref.GetObjectId().GetName())) { commits.AddItem("'" + @ref.GetName() + "'"); } else { others.AddItem(@ref.GetName()); } } } } } IList<string> listings = new AList<string>(); if (!branches.IsEmpty()) { listings.AddItem(JoinNames(branches, "branch", "branches")); } if (!remoteBranches.IsEmpty()) { listings.AddItem(JoinNames(remoteBranches, "remote branch", "remote branches")); } if (!tags.IsEmpty()) { listings.AddItem(JoinNames(tags, "tag", "tags")); } if (!commits.IsEmpty()) { listings.AddItem(JoinNames(commits, "commit", "commits")); } if (!others.IsEmpty()) { listings.AddItem(StringUtils.Join(others, ", ", " and ")); } sb.Append(StringUtils.Join(listings, ", ")); string targetName = target.GetLeaf().GetName(); if (!targetName.Equals(Constants.R_HEADS + Constants.MASTER)) { string targetShortName = Repository.ShortenRefName(target.GetName()); sb.Append(" into " + targetShortName); } return sb.ToString(); }
/// <exception cref="NGit.Errors.TransportException"></exception> public virtual SystemProcess Exec(string command, int timeout) { string ssh = SystemReader.GetInstance().Getenv("GIT_SSH"); bool putty = ssh.ToLower().Contains("plink"); IList<string> args = new AList<string>(); args.AddItem(ssh); if (putty && !ssh.ToLower().Contains("tortoiseplink")) { args.AddItem("-batch"); } if (0 < this._enclosing.GetURI().GetPort()) { args.AddItem(putty ? "-P" : "-p"); args.AddItem(this._enclosing.GetURI().GetPort().ToString()); } if (this._enclosing.GetURI().GetUser() != null) { args.AddItem(this._enclosing.GetURI().GetUser() + "@" + this._enclosing.GetURI(). GetHost()); } else { args.AddItem(this._enclosing.GetURI().GetHost()); } args.AddItem(command); ProcessStartInfo pb = new ProcessStartInfo(); pb.SetCommand(args); if (this._enclosing.local.Directory != null) { pb.EnvironmentVariables.Put(Constants.GIT_DIR_KEY, this._enclosing.local.Directory .GetPath()); } try { return pb.Start(); } catch (IOException err) { throw new TransportException(err.Message, err); } }
private static Operator[] GetOperatorsFromLexeme(Operator[] ops, Lexeme lex) { AList<Operator> list = new AList<Operator>(); foreach (Operator op in ops) { if (lex.GetType() == Lexeme.OPERATOR && lex.GetValue().Equals(op.symbol)) { list.AddItem(op); } } return Sharpen.Collections.ToArray(list, new Operator[list.Count]); }
public IList<string> GetAllDatabaseNames() { string[] databaseFiles = directoryFile.List(new _FilenameFilter_178()); IList<string> result = new AList<string>(); foreach (string databaseFile in databaseFiles) { string trimmed = Sharpen.Runtime.Substring(databaseFile, 0, databaseFile.Length - Couchbase.Lite.Manager.DatabaseSuffix.Length); string replaced = trimmed.Replace(':', '/'); result.AddItem(replaced); } result.Sort(); return Sharpen.Collections.UnmodifiableList(result); }
/// <summary>Returns an expression-tree that represents the expression string.</summary> /// <remarks>Returns an expression-tree that represents the expression string. Returns null if the string is empty. /// </remarks> /// <exception cref="ExpressionParseException">If the string is invalid.</exception> public static Expression Parse(string s) { if (s == null) { throw new ExpressionParseException("Expression string cannot be null.", -1); } AList<Lexeme> lexemes = Lexify(s); //Make tokens System.Console.Out.WriteLine("Lexemes:"); foreach (Lexeme item in lexemes) { System.Console.Out.Write(item.ToString()); } Operator[] operators = GetOperators(); string nl = Runtime.GetProperty("line.separator"); System.Console.Out.WriteLine(nl + "Operators:"); foreach (Operator oper in operators) { System.Console.Out.Write(oper.ToString() + " "); } System.Console.Out.Write(nl); //build tree Stack<Expression> terms = new Stack<Expression>(); Stack<Expression> exprOps = new Stack<Expression>(); Stack<Expression> exprList = new Stack<Expression>(); Stack<Operator> opStack = new Stack<Operator>(); Stack<Lexeme> operands = new Stack<Lexeme>(); // contains expression nodes Stack<Lexeme> ops = new Stack<Lexeme>(); // contains open brackets ( and operators ^,*,/,+,- //boolean term = true; // indicates a term should come next, not an operator //boolean signed = false; // indicates if the current term has been signed //boolean negate = false; // indicates if the sign of the current term is negated bool inTermOrPostOp = false; //1. While there are still tokens to be read in for (int i = 0; i < lexemes.Count; i++) { //1.1 Get the next token. Expression contents; Operator currentOperator; Lexeme current = lexemes[i]; switch (current.GetType()) { case Lexeme.NUMBER: { //1.2.1 A number: push it onto the value stack. inTermOrPostOp = true; operands.AddItem(current); if (debuggging) { System.Console.Out.WriteLine("push term: " + current.GetValue()); } terms.AddItem(new NumberNode(current.GetValue())); break; } case Lexeme.WORD: { //1.2.2 A variable: get its value, and push onto the value stack. //maybe variable, maybe function name? operands.AddItem(current); inTermOrPostOp = true; terms.AddItem(new VariableNode(current.GetValue())); if (debuggging) { System.Console.Out.WriteLine("push term: " + current.GetValue()); } break; } case Lexeme.LPAREN: { //1.2.3 A left parenthesis: push it onto the operator stack. inTermOrPostOp = false; //is function if (!operands.IsEmpty() && operands.Peek().GetType() == Lexeme.WORD) { Expression funcName = terms.Pop(); currentOperator = GetOperatorFromLexeme(operators, operands.Peek(), inTermOrPostOp ); opStack.AddItem(currentOperator); if (debuggging) { System.Console.Out.WriteLine("push: " + currentOperator.GetSymbol()); } } ops.AddItem(current); currentOperator = GetOperatorFromLexeme(operators, current, inTermOrPostOp); opStack.AddItem(currentOperator); if (debuggging) { System.Console.Out.WriteLine("push: " + currentOperator.GetSymbol()); } break; } case Lexeme.COMMA: { operands.AddItem(current); while (!opStack.IsEmpty() && (!opStack.Peek().GetSymbol().Equals("(") && !opStack .Peek().GetSymbol().Equals(","))) { Operator topOperator = opStack.Pop(); if (debuggging) { System.Console.Out.WriteLine("pop: " + topOperator.GetSymbol()); } Expression[] children; if (topOperator.IsBinary()) { Expression operand1 = terms.Pop(); Expression operand2 = terms.Pop(); children = new Expression[] { operand2, operand1 }; } else { //check assoc here Expression operand = terms.Pop(); children = new Expression[] { operand }; } terms.AddItem(new OpNode(children, topOperator)); } inTermOrPostOp = false; if (!opStack.IsEmpty()) { opStack.Pop(); } else { // remove '(' paren from stack; throw new ExpressionParseException("Expression string cannot missing leading (" + current, i); } currentOperator = GetOperatorFromLexeme(operators, current, inTermOrPostOp); opStack.AddItem(currentOperator); //terms.add(terms.pop()); break; } case Lexeme.RPAREN: { //1.2.4 A right parenthesis: operands.AddItem(current); while (!opStack.IsEmpty() && (!opStack.Peek().GetSymbol().Equals("(") && !opStack .Peek().GetSymbol().Equals(","))) { Operator topOperator = opStack.Pop(); if (debuggging) { System.Console.Out.WriteLine("pop: " + topOperator.GetSymbol()); } Expression[] children; if (topOperator.IsBinary()) { Expression operand1 = terms.Pop(); Expression operand2 = terms.Pop(); children = new Expression[] { operand2, operand1 }; } else { //check assoc here Expression operand = terms.Pop(); children = new Expression[] { operand }; } terms.AddItem(new OpNode(children, topOperator)); } inTermOrPostOp = true; //maybe check if paren? if (!opStack.IsEmpty()) { opStack.Pop(); } else { // remove '(' paren from stack; throw new ExpressionParseException("Expression string cannot missing leading (", i); } if (!opStack.IsEmpty() && opStack.Peek().IsFunc()) { AList<Expression> args = new AList<Expression>(); while (!terms.IsEmpty()) { if (args.Count < opStack.Peek().GetOperandsSize()) { args.AddItem(terms.Pop()); } else { break; } } //check if args.size()==opStack.peek().getOperandsSize() Collections.Reverse(args); terms.AddItem(new FuncNode(opStack.Peek().GetSymbol(), Sharpen.Collections.ToArray (args, new Expression[args.Count]), opStack.Pop())); } else { contents = terms.Pop(); terms.AddItem(new ParensNode(new Expression[] { contents })); } break; } case Lexeme.OPERATOR: { Lexeme thisOp = current; currentOperator = GetOperatorFromLexeme(operators, current, inTermOrPostOp); inTermOrPostOp = false; operands.AddItem(current); //Operator topOp; while (!opStack.IsEmpty() && opStack.Peek().GetPrecednce() >= currentOperator.GetPrecednce ()) { //Lexeme poppedOp = ops.pop(); Operator topOperator = opStack.Pop(); Expression[] children; if (topOperator.IsBinary()) { Expression operand1 = terms.Pop(); Expression operand2 = terms.Pop(); children = new Expression[] { operand2, operand1 }; } else { //check assoc here Expression operand = terms.Pop(); children = new Expression[] { operand }; } terms.AddItem(new OpNode(children, topOperator)); } //Apply the operator to the operands, in the correct order. //4 Push the result onto the value stack. //might have to go x->pop(), y->pop(); push(x) for right assoc unary //ops.add(current); opStack.AddItem(currentOperator); break; } default: { throw new ExpressionParseException("Unknown token type", -1); } } } //2. While the operator stack is not empty while (!opStack.IsEmpty()) { Operator poppedOp = opStack.Pop(); Expression[] children; if (poppedOp.IsBinary()) { Expression operand1 = terms.Pop(); Expression operand2 = terms.Pop(); children = new Expression[] { operand2, operand1 }; } else { //check assoc here Expression operand = terms.Pop(); children = new Expression[] { operand }; } terms.AddItem(new OpNode(children, poppedOp)); } return terms.Peek(); }
internal Cursor ResultSetWithOptions(QueryOptions options) { if (options == null) { options = new QueryOptions(); } // OPT: It would be faster to use separate tables for raw-or ascii-collated views so that // they could be indexed with the right Collation, instead of having to specify it here. var collationStr = string.Empty; if (Collation == ViewCollation.ASCII) { collationStr += " COLLATE JSON_ASCII"; } else { if (Collation == ViewCollation.Raw) { collationStr += " COLLATE JSON_RAW"; } } var sql = "SELECT key, value, docid, revs.sequence"; if (options.IsIncludeDocs()) { sql = sql + ", revid, json"; } sql = sql + " FROM maps, revs, docs WHERE maps.view_id=@"; var argsList = new AList<string>(); argsList.AddItem(Sharpen.Extensions.ToString(Id)); if (options.GetKeys() != null) { sql += " AND key in ("; var item = "@"; foreach (object key in options.GetKeys()) { sql += item; item = ", @"; argsList.AddItem(ToJSONString(key)); } sql += ")"; } var minKey = options.GetStartKey(); var maxKey = options.GetEndKey(); var inclusiveMin = true; var inclusiveMax = options.IsInclusiveEnd(); if (options.IsDescending()) { minKey = maxKey; maxKey = options.GetStartKey(); inclusiveMin = inclusiveMax; inclusiveMax = true; } if (minKey != null) { System.Diagnostics.Debug.Assert((minKey is string)); sql += inclusiveMin ? " AND key >= @" : " AND key > @"; sql += collationStr; argsList.AddItem(ToJSONString(minKey)); } if (maxKey != null) { System.Diagnostics.Debug.Assert((maxKey is string)); if (inclusiveMax) { sql += " AND key <= @"; } else { sql += " AND key < @"; } sql += collationStr; argsList.AddItem(ToJSONString(maxKey)); } sql = sql + " AND revs.sequence = maps.sequence AND docs.doc_id = revs.doc_id ORDER BY key"; sql += collationStr; if (options.IsDescending()) { sql = sql + " DESC"; } sql = sql + " LIMIT @ OFFSET @"; argsList.AddItem(options.GetLimit().ToString()); argsList.AddItem(options.GetSkip().ToString()); Log.V(Database.Tag, "Query " + Name + ": " + sql); var cursor = Database.StorageEngine.RawQuery(sql, CommandBehavior.SequentialAccess, argsList.ToArray()); return cursor; }
/// <exception cref="Couchbase.Lite.CouchbaseLiteException"></exception> internal IList<QueryRow> ReducedQuery(Cursor cursor, Boolean group, Int32 groupLevel) { IList<object> keysToReduce = null; IList<object> valuesToReduce = null; object lastKey = null; var reduce = Reduce; // FIXME: If reduce is null, then so are keysToReduce and ValuesToReduce, which can throw an NRE below. if (reduce != null) { keysToReduce = new AList<Object>(ReduceBatchSize); valuesToReduce = new AList<Object>(ReduceBatchSize); } var rows = new AList<QueryRow>(); cursor.MoveToNext(); while (!cursor.IsAfterLast()) { var keyData = FromJSON(cursor.GetBlob(0)); var value = FromJSON(cursor.GetBlob(1)); System.Diagnostics.Debug.Assert((keyData != null)); if (group && !GroupTogether(keyData, lastKey, groupLevel)) { if (lastKey != null) { // This pair starts a new group, so reduce & record the last one: var reduced = (reduce != null) ? reduce(keysToReduce, valuesToReduce, false) : null; var key = GroupKey(lastKey, groupLevel); var row = new QueryRow(null, 0, key, reduced, null); row.Database = Database; rows.AddItem(row); // NOTE.ZJG: Change to `yield return row` to convert to a generator. keysToReduce.Clear(); valuesToReduce.Clear(); } lastKey = keyData; } keysToReduce.AddItem(keyData); valuesToReduce.AddItem(value); cursor.MoveToNext(); } // NOTE.ZJG: Need to handle grouping differently if switching this to a generator. if (keysToReduce.Count > 0) { // Finish the last group (or the entire list, if no grouping): var key = group ? GroupKey(lastKey, groupLevel) : null; var reduced = (reduce != null) ? reduce(keysToReduce, valuesToReduce, false) : null; var row = new QueryRow(null, 0, key, reduced, null); row.Database = Database; rows.AddItem(row); } return rows; }
/// <summary>Queries the view.</summary> /// <remarks>Queries the view. Does NOT first update the index.</remarks> /// <param name="options">The options to use.</param> /// <returns>An array of QueryRow objects.</returns> /// <exception cref="Couchbase.Lite.CouchbaseLiteException"></exception> internal IEnumerable<QueryRow> QueryWithOptions(QueryOptions options) { if (options == null) options = new QueryOptions(); Cursor cursor = null; IList<QueryRow> rows = new AList<QueryRow>(); try { cursor = ResultSetWithOptions(options); int groupLevel = options.GetGroupLevel(); var group = options.IsGroup() || (groupLevel > 0); var reduce = options.IsReduce() || group; var reduceBlock = Reduce; if (reduce && (reduceBlock == null) && !group) { var msg = "Cannot use reduce option in view " + Name + " which has no reduce block defined"; Log.W(Database.Tag, msg); throw new CouchbaseLiteException(StatusCode.BadRequest); } if (reduce || group) { // Reduced or grouped query: rows = ReducedQuery(cursor, group, groupLevel); } else { // regular query cursor.MoveToNext(); while (!cursor.IsAfterLast()) { var keyData = FromJSON(cursor.GetBlob(0)); // TODO: delay parsing this for increased efficiency var value = FromJSON(cursor.GetBlob(1)); // TODO: ditto var docId = cursor.GetString(2); var sequenceLong = cursor.GetLong(3); var sequence = Convert.ToInt32(sequenceLong); IDictionary<string, object> docContents = null; if (options.IsIncludeDocs()) { // http://wiki.apache.org/couchdb/Introduction_to_CouchDB_views#Linked_documents if (value is IDictionary<string,object> && ((IDictionary<string,object>)value).ContainsKey("_id")) { string linkedDocId = (string)((IDictionary<string,object>)value).Get("_id"); RevisionInternal linkedDoc = Database.GetDocumentWithIDAndRev(linkedDocId, null, EnumSet.NoneOf<TDContentOptions>()); docContents = linkedDoc.GetProperties(); } else { var revId = cursor.GetString(4); docContents = Database.DocumentPropertiesFromJSON(cursor.GetBlob(5), docId, revId, false, sequenceLong, options.GetContentOptions()); } } var row = new QueryRow(docId, sequence, keyData, value, docContents); row.Database = Database; rows.AddItem<QueryRow>(row); // NOTE.ZJG: Change to `yield return row` to convert to a generator. cursor.MoveToNext(); } } } catch (SQLException e) { var errMsg = string.Format("Error querying view: {0}", this); Log.E(Database.Tag, errMsg, e); throw new CouchbaseLiteException(errMsg, e, new Status(StatusCode.DbError)); } finally { if (cursor != null) { cursor.Close(); } } return rows; }
/// <exception cref="System.IO.IOException"></exception> private void ResolveDeltasWithExternalBases(ProgressMonitor progress) { GrowEntries(baseById.Size()); if (needBaseObjectIds) { baseObjectIds = new ObjectIdSubclassMap<ObjectId>(); } IList<PackParser.DeltaChain> missing = new AList<PackParser.DeltaChain>(64); foreach (PackParser.DeltaChain baseId in baseById) { if (baseId.head == null) { continue; } if (needBaseObjectIds) { baseObjectIds.Add(baseId); } ObjectLoader ldr; try { ldr = readCurs.Open(baseId); } catch (MissingObjectException) { missing.AddItem(baseId); continue; } PackParser.DeltaVisit visit = new PackParser.DeltaVisit(); visit.data = ldr.GetCachedBytes(int.MaxValue); visit.id = baseId; int typeCode = ldr.GetType(); PackedObjectInfo oe = NewInfo(baseId, null, null); if (OnAppendBase(typeCode, visit.data, oe)) { entries[entryCount++] = oe; } visit.nextChild = FirstChildOf(oe); ResolveDeltas(visit.Next(), typeCode, new PackParser.ObjectTypeAndSize(), progress ); if (progress.IsCancelled()) { throw new IOException(JGitText.Get().downloadCancelledDuringIndexing); } } foreach (PackParser.DeltaChain @base in missing) { if (@base.head != null) { throw new MissingObjectException(@base, "delta base"); } } OnEndThinPack(); }
/// <summary> /// Find commits that are reachable from <code>start</code> until a commit /// that is reachable from <code>end</code> is encountered. /// </summary> /// <remarks> /// Find commits that are reachable from <code>start</code> until a commit /// that is reachable from <code>end</code> is encountered. In other words, /// Find of commits that are in <code>start</code>, but not in /// <code>end</code>. /// <p> /// Note that this method calls /// <see cref="RevWalk.Reset()">RevWalk.Reset()</see> /// at the beginning. /// Also note that the existing rev filter on the walk is left as-is, so be /// sure to set the right rev filter before calling this method. /// </remarks> /// <param name="walk">the rev walk to use</param> /// <param name="start">the commit to start counting from</param> /// <param name="end"> /// the commit where counting should end, or null if counting /// should be done until there are no more commits /// </param> /// <returns>the commits found</returns> /// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public static IList<RevCommit> Find(RevWalk walk, RevCommit start, RevCommit end) { walk.Reset(); walk.MarkStart(start); if (end != null) { walk.MarkUninteresting(end); } IList<RevCommit> commits = new AList<RevCommit>(); foreach (RevCommit c in walk) { commits.AddItem(c); } return commits; }
public virtual void TestMakeRevisionHistoryDict() { IList<RevisionInternal> revs = new AList<RevisionInternal>(); revs.AddItem(Mkrev("4-jkl")); revs.AddItem(Mkrev("3-ghi")); revs.AddItem(Mkrev("2-def")); IList<string> expectedSuffixes = new AList<string>(); expectedSuffixes.AddItem("jkl"); expectedSuffixes.AddItem("ghi"); expectedSuffixes.AddItem("def"); IDictionary<string, object> expectedHistoryDict = new Dictionary<string, object>( ); expectedHistoryDict.Put("start", 4); expectedHistoryDict.Put("ids", expectedSuffixes); IDictionary<string, object> historyDict = Database.MakeRevisionHistoryDict(revs); NUnit.Framework.Assert.AreEqual(expectedHistoryDict, historyDict); revs = new AList<RevisionInternal>(); revs.AddItem(Mkrev("4-jkl")); revs.AddItem(Mkrev("2-def")); expectedSuffixes = new AList<string>(); expectedSuffixes.AddItem("4-jkl"); expectedSuffixes.AddItem("2-def"); expectedHistoryDict = new Dictionary<string, object>(); expectedHistoryDict.Put("ids", expectedSuffixes); historyDict = Database.MakeRevisionHistoryDict(revs); NUnit.Framework.Assert.AreEqual(expectedHistoryDict, historyDict); revs = new AList<RevisionInternal>(); revs.AddItem(Mkrev("12345")); revs.AddItem(Mkrev("6789")); expectedSuffixes = new AList<string>(); expectedSuffixes.AddItem("12345"); expectedSuffixes.AddItem("6789"); expectedHistoryDict = new Dictionary<string, object>(); expectedHistoryDict.Put("ids", expectedSuffixes); historyDict = Database.MakeRevisionHistoryDict(revs); NUnit.Framework.Assert.AreEqual(expectedHistoryDict, historyDict); }
public static AList<Lexeme> Lexify(string s) { int position = 0; string[] tokens = GetAllMatches(s); foreach (string token in tokens) { System.Console.Out.WriteLine(token); } AList<Lexeme> tokBuf = new AList<Lexeme>(); //try { foreach (string token_1 in tokens) { position += token_1.Length; Lexer.TokenType type = Lexer.TokenType.UNSET; if (token_1.Matches("^[0-9]+$")) { type = Lexer.TokenType.INT; } else { if (token_1.Matches("^[0-9]*\\.[0-9]+$")) { type = Lexer.TokenType.DECIMAL; } else { if (token_1.Matches("^([a-zA-Z]+)$")) { type = Lexer.TokenType.WORD; } else { if (token_1.Matches("^([^\\w\\s])$")) { type = Lexer.TokenType.OPERATOR; } } } } switch (type) { case Lexer.TokenType.INT: { // int tokBuf.AddItem(new Lexeme(Lexeme.NUMBER, token_1)); break; } case Lexer.TokenType.DECIMAL: { // double tokBuf.AddItem(new Lexeme(Lexeme.NUMBER, token_1)); break; } case Lexer.TokenType.WORD: { tokBuf.AddItem(new Lexeme(Lexeme.WORD, token_1)); break; } case Lexer.TokenType.OPERATOR: { // operator if (token_1.Equals("(")) { tokBuf.AddItem(new Lexeme(Lexeme.LPAREN, token_1)); } else { if (token_1.Equals(")")) { tokBuf.AddItem(new Lexeme(Lexeme.RPAREN, token_1)); } else { if (token_1.Equals(",")) { tokBuf.AddItem(new Lexeme(Lexeme.COMMA, token_1)); } else { tokBuf.AddItem(new Lexeme(Lexeme.OPERATOR, token_1)); } } } break; } } } return tokBuf; }