コード例 #1
0
        public string this[string key]
        {
            get
            {
                var entry = list.FirstOrDefault(e => e.Key.Equals(key));

                if (entry == null)
                    return null;

                return entry.Value;
            }
            set
            {
                var entry = list.FirstOrDefault(p => p.Key.Equals(key));

                if (entry == null)
                {
                    entry = new MetadataEntry();
                    entry.Key = key;
                    list.Add(entry);
                }

                entry.Value = value;

                if (string.IsNullOrEmpty(entry.Value))
                    list.Remove(entry);
            }
        }
コード例 #2
0
 public void MetadataUpdated(OperationContext context, StrongFingerprint strongFingerprint, MetadataEntry entry)
 {
     Events.Add(new UpdateMetadataEntryEventData(Sender, strongFingerprint, entry));
 }
コード例 #3
0
ファイル: Entity.cs プロジェクト: sccGg/MiNET
        public static string MetadataToCode(MetadataDictionary metadata)
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendLine();
            sb.AppendLine("MetadataDictionary metadata = new MetadataDictionary();");

            foreach (var kvp in metadata._entries)
            {
                int           idx   = kvp.Key;
                MetadataEntry entry = kvp.Value;

                sb.Append($"metadata[{idx}] = new ");
                switch (entry.Identifier)
                {
                case 0:
                {
                    var e = (MetadataByte)entry;
                    sb.Append($"{e.GetType().Name}({e.Value});");
                    break;
                }

                case 1:
                {
                    var e = (MetadataShort)entry;
                    sb.Append($"{e.GetType().Name}({e.Value});");
                    break;
                }

                case 2:
                {
                    var e = (MetadataInt)entry;
                    sb.Append($"{e.GetType().Name}({e.Value});");
                    break;
                }

                case 3:
                {
                    var e = (MetadataFloat)entry;
                    sb.Append($"{e.GetType().Name}({e.Value.ToString(NumberFormatInfo.InvariantInfo)}f);");
                    break;
                }

                case 4:
                {
                    var e = (MetadataString)entry;
                    sb.Append($"{e.GetType().Name}(\"{e.Value}\");");
                    break;
                }

                case 5:
                {
                    var e = (MetadataNbt)entry;
                    sb.Append($"{e.GetType().Name}({e.Value});");
                    break;
                }

                case 6:
                {
                    var e = (MetadataIntCoordinates)entry;
                    sb.Append($"{e.GetType().Name}({e.Value});");
                    break;
                }

                case 7:
                {
                    var e = (MetadataLong)entry;
                    sb.Append($"{e.GetType().Name}({e.Value});");
                    if (idx == 0)
                    {
                        sb.Append($" // {Convert.ToString((long) e.Value, 2)}; {FlagsToString(e.Value)}");
                    }
                    break;
                }

                case 8:
                {
                    var e = (MetadataVector3)entry;
                    sb.Append($"{e.GetType().Name}({e.Value});");
                    break;
                }
                }
                sb.AppendLine();
            }

            return(sb.ToString());
        }
コード例 #4
0
ファイル: AmazonS3.cs プロジェクト: tetuji/stickies-windows
 /// <remarks/>
 public void PutObjectInlineAsync(string Bucket, string Key, MetadataEntry[] Metadata, byte[] Data, long ContentLength, Grant[] AccessControlList, StorageClass StorageClass, bool StorageClassSpecified, string AWSAccessKeyId, System.DateTime Timestamp, bool TimestampSpecified, string Signature, string Credential, object userState) {
     if ((this.PutObjectInlineOperationCompleted == null)) {
         this.PutObjectInlineOperationCompleted = new System.Threading.SendOrPostCallback(this.OnPutObjectInlineOperationCompleted);
     }
     this.InvokeAsync("PutObjectInline", new object[] {
                 Bucket,
                 Key,
                 Metadata,
                 Data,
                 ContentLength,
                 AccessControlList,
                 StorageClass,
                 StorageClassSpecified,
                 AWSAccessKeyId,
                 Timestamp,
                 TimestampSpecified,
                 Signature,
                 Credential}, this.PutObjectInlineOperationCompleted, userState);
 }
コード例 #5
0
ファイル: Metadata.cs プロジェクト: wfarr/grpc
 public Builder Add(MetadataEntry entry)
 {
     entries.Add(entry);
     return(this);
 }
コード例 #6
0
ファイル: AmazonS3.cs プロジェクト: tetuji/stickies-windows
 /// <remarks/>
 public System.IAsyncResult BeginPutObjectInline(string Bucket, string Key, MetadataEntry[] Metadata, byte[] Data, long ContentLength, Grant[] AccessControlList, StorageClass StorageClass, bool StorageClassSpecified, string AWSAccessKeyId, System.DateTime Timestamp, bool TimestampSpecified, string Signature, string Credential, System.AsyncCallback callback, object asyncState) {
     return this.BeginInvoke("PutObjectInline", new object[] {
                 Bucket,
                 Key,
                 Metadata,
                 Data,
                 ContentLength,
                 AccessControlList,
                 StorageClass,
                 StorageClassSpecified,
                 AWSAccessKeyId,
                 Timestamp,
                 TimestampSpecified,
                 Signature,
                 Credential}, callback, asyncState);
 }
コード例 #7
0
ファイル: AmazonS3.cs プロジェクト: tetuji/stickies-windows
 /// <remarks/>
 public void PutObjectInlineAsync(string Bucket, string Key, MetadataEntry[] Metadata, byte[] Data, long ContentLength, Grant[] AccessControlList, StorageClass StorageClass, bool StorageClassSpecified, string AWSAccessKeyId, System.DateTime Timestamp, bool TimestampSpecified, string Signature, string Credential) {
     this.PutObjectInlineAsync(Bucket, Key, Metadata, Data, ContentLength, AccessControlList, StorageClass, StorageClassSpecified, AWSAccessKeyId, Timestamp, TimestampSpecified, Signature, Credential, null);
 }
コード例 #8
0
ファイル: Entity.cs プロジェクト: astroffnet/Alex
 protected virtual bool HandleMetadata(MiNET.Entities.Entity.MetadataFlags flag, MetadataEntry entry)
 {
     return(false);
 }
コード例 #9
0
 public long MetadataUpdated(OperationContext context, StrongFingerprint strongFingerprint, MetadataEntry entry)
 {
     Interlocked.Increment(ref _eventsHandled);
     return(1);
 }
コード例 #10
0
        public void RemoveEntry(MetadataEntry entry)
        {
            int fileId = GetFileID(entry.FileName);

            _backupFiles[fileId].RemoveEntry(entry);
        }
コード例 #11
0
        private static Document GetOrientedDocument(byte[] bytes, out ExifValueCollection exifMetadata)
        {
            exifMetadata = null;

            Document doc = null;

            // Load the image into a Bitmap so the EXIF orientation transform can be applied.

            using (Bitmap image = WebPFile.Load(bytes))
            {
                byte[] exifBytes = WebPFile.GetExifBytes(bytes);
                if (exifBytes != null)
                {
                    exifMetadata = ExifParser.Parse(exifBytes);

                    if (exifMetadata.Count > 0)
                    {
                        MetadataEntry orientationProperty = exifMetadata.GetAndRemoveValue(MetadataKeys.Image.Orientation);
                        if (orientationProperty != null)
                        {
                            RotateFlipType transform = MetadataHelpers.GetOrientationTransform(orientationProperty);
                            if (transform != RotateFlipType.RotateNoneFlipNone)
                            {
                                image.RotateFlip(transform);
                            }
                        }

                        MetadataEntry xResProperty    = exifMetadata.GetAndRemoveValue(MetadataKeys.Image.XResolution);
                        MetadataEntry yResProperty    = exifMetadata.GetAndRemoveValue(MetadataKeys.Image.YResolution);
                        MetadataEntry resUnitProperty = exifMetadata.GetAndRemoveValue(MetadataKeys.Image.ResolutionUnit);
                        if (xResProperty != null && yResProperty != null && resUnitProperty != null)
                        {
                            if (MetadataHelpers.TryDecodeRational(xResProperty, out double xRes) &&
                                MetadataHelpers.TryDecodeRational(yResProperty, out double yRes) &&
                                MetadataHelpers.TryDecodeShort(resUnitProperty, out ushort resUnit))
                            {
                                if (xRes > 0.0 && yRes > 0.0)
                                {
                                    double dpiX, dpiY;

                                    switch ((MeasurementUnit)resUnit)
                                    {
                                    case MeasurementUnit.Centimeter:
                                        dpiX = Document.DotsPerCmToDotsPerInch(xRes);
                                        dpiY = Document.DotsPerCmToDotsPerInch(yRes);
                                        break;

                                    case MeasurementUnit.Inch:
                                        dpiX = xRes;
                                        dpiY = yRes;
                                        break;

                                    default:
                                        // Unknown ResolutionUnit value.
                                        dpiX = 0.0;
                                        dpiY = 0.0;
                                        break;
                                    }

                                    if (dpiX > 0.0 && dpiY > 0.0)
                                    {
                                        try
                                        {
                                            image.SetResolution((float)dpiX, (float)dpiY);
                                        }
                                        catch
                                        {
                                            // Ignore any errors when setting the resolution.
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                doc = Document.FromGdipImage(image);
            }

            return(doc);
        }
コード例 #12
0
        public void LoadFromFile(ConcurrentDictionary <string, MetadataEntry> table)
        {
            XmlDocument doc = new XmlDocument( );

            doc.XmlResolver = null;
            try
            {
                doc.LoadXml(File.ReadAllText(_filePath) + "</ROOT>");
            }
            catch (Exception)
            {
                Console.WriteLine("Empty xml file");
                return;
            }

            List <String> filesDeleted = new List <string>( );
            //Ler do fim para o inicio, se ja existe, ignora porque e mais antigo
            XmlNodeList nodeList = doc.SelectNodes("//entry");

            for (int i = nodeList.Count - 1; i >= 0; i--)
            {
                XmlNode element   = nodeList[i];
                String  operation = element.ChildNodes[0].LocalName;

                //FileName
                String        filename = element.ChildNodes[0].InnerText;
                MetadataEntry ignore;
                if (operation == "Delete")
                {
                    filesDeleted.Add(filename);
                }
                if (filesDeleted.Contains(filename))
                {
                    continue;
                }

                if (table.TryGetValue(filename, out ignore))
                {
                    continue;
                }

                //NBDataServers
                int nBDataServers = Convert.ToInt32(element.ChildNodes[1].InnerText);
                //ReadQuorum
                int readQuorum = Convert.ToInt32(element.ChildNodes[2].InnerText);
                //WriteQuorum
                int writeQuorum = Convert.ToInt32(element.ChildNodes[3].InnerText);

                MetadataEntry entry = new MetadataEntry(filename, nBDataServers, readQuorum, writeQuorum);
                //ServerList
                foreach (XmlNode node in element.ChildNodes[4])
                {
                    ServerId server;
                    server.id          = node.ChildNodes[0].InnerText;
                    server.hostname    = node.ChildNodes[1].InnerText;
                    server.port        = Convert.ToInt32(node.ChildNodes[2].InnerText);
                    server.recoverPort = Convert.ToInt32(node.ChildNodes[3].InnerText);
                    String fileName = node.ChildNodes[4].InnerText;
                    entry.ServerFileList.TryAdd(server, fileName);
                }
                table.TryAdd(filename, entry);
            }
        }
コード例 #13
0
        /// <inheritdoc />
        protected override bool HandleMetadata(MiNET.Entities.Entity.MetadataFlags flag, MetadataEntry entry)
        {
            if (flag == MiNET.Entities.Entity.MetadataFlags.Variant && entry is MetadataInt mdi)
            {
                var blockState = ChunkProcessor.Instance.GetBlockState((uint)mdi.Value);

                if (ItemFactory.TryGetItem(blockState.Name, out var item))
                {
                    SetItem(item);
                }
                else
                {
                    Log.Info($"Could not get item: {blockState.Name}");
                }

                return(true);
            }

            return(base.HandleMetadata(flag, entry));
        }
コード例 #14
0
ファイル: Metadata.cs プロジェクト: jwatt/kythe
 public Builder Add(MetadataEntry entry)
 {
     entries.Add(entry);
     return this;
 }
コード例 #15
0
 /// <nodoc />
 public UpdateMetadataEntryEventData(MachineId sender, BuildXLReader reader)
     : base(EventKind.UpdateMetadataEntry, sender, CollectionUtilities.EmptyArray <ShortHash>())
 {
     StrongFingerprint = StrongFingerprint.Deserialize(reader);
     Entry             = MetadataEntry.Deserialize(reader);
 }
コード例 #16
0
 /// <nodoc />
 public UpdateMetadataEntryEventData(MachineId sender, StrongFingerprint strongFingerprint, MetadataEntry entry)
     : base(EventKind.UpdateMetadataEntry, sender, CollectionUtilities.EmptyArray <ShortHash>())
 {
     StrongFingerprint = strongFingerprint;
     Entry             = entry;
 }