コード例 #1
0
ファイル: Schemas.cs プロジェクト: modulexcite/SDSlite
		internal VariableSchema(int changeSetId, int id, Type dataType, ReadOnlyDimensionList dimensions, string[] cs, MetadataDictionary metadata)
		{
			if (dimensions == null)
				throw new ArgumentNullException("dimensions");
			if (metadata == null)
				throw new ArgumentNullException("metadata");
			this.changeSetId = changeSetId;
			this.id = id;
			this.dimensions = dimensions;
			this.cs = cs;
			this.metadata = metadata;
			this.dataType = dataType;
		}
コード例 #2
0
 public void ApplyMetadataChanges(int id, MetadataDictionary mc)
 {
     DataSet targetDS = Target;
     if (targetDS != null)
     {
         int targetID;
         if (targetVars.TryGetValue(id, out targetID))
         {
             Variable v = targetDS.Variables.GetByID(targetID);
             foreach (var p in mc)
                 v.Metadata[p.Key] = p.Value;
         }
     }
 }
コード例 #3
0
            public void ContainsPreviousValues()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary {
                    ["A"] = "a"
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                MetadataStack clone = metadata.Clone(new Dictionary <string, object> {
                    { "B", "b" }
                });

                // Then
                Assert.AreEqual("a", clone["A"]);
            }
コード例 #4
0
            public void ReturnsFalseForInvalidValue()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary {
                    ["A"] = "a"
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                object value;
                bool   contains = metadata.TryGetValue("B", out value);

                // Then
                Assert.IsFalse(contains);
                Assert.AreEqual(null, value);
            }
コード例 #5
0
            public void ClonedMetadataDoesNotContainNewValues()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary {
                    ["A"] = "a"
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                MetadataStack clone = metadata.Clone(new Dictionary <string, object> {
                    { "B", "b" }
                });

                // Then
                Assert.IsFalse(metadata.ContainsKey("B"));
            }
コード例 #6
0
        public override MetadataDictionary GetMetadata()
        {
            IsInWater   = true;
            IsUsingItem = false;

            var metadata = base.GetMetadata();

            if (Shooter != null)
            {
                metadata[5] = new MetadataLong(Shooter.EntityId);
            }

            Log.Debug($"Projectile metadata: \n{MetadataDictionary.MetadataToCode(metadata)}");

            return(metadata);
        }
コード例 #7
0
 private static string GetName(MetadataDictionary vm)
 {
     if (vm == null)
     {
         throw new ArgumentNullException("metadata");
     }
     if (vm.ContainsKey(vm.KeyForName))
     {
         return((string)vm[vm.KeyForName, SchemaVersion.Committed]);
     }
     else if (vm.ContainsKey(vm.KeyForName, SchemaVersion.Proposed))
     {
         return((string)vm[vm.KeyForName, SchemaVersion.Proposed]);
     }
     return("");
 }
コード例 #8
0
            public void ConvertStringEnumerableToIntArray()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary();
                MetadataStack      metadata        = new MetadataStack(initialMetadata);

                // When
                metadata = metadata.Clone(new[] { new KeyValuePair <string, object>("A", new List <string> {
                        "1", "2", "3"
                    }) });
                IMetadata <int[]> metadataAs = metadata.MetadataAs <int[]>();

                // Then
                CollectionAssert.AreEqual(new string[] { "1", "2", "3" }, (IEnumerable)metadata["A"]);
                CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, (IEnumerable)metadataAs["A"]);
            }
コード例 #9
0
            public void ReturnsListForSingleDocument()
            {
                // Given
                IDocument          a = Substitute.For <IDocument>();
                MetadataDictionary initialMetadata = new MetadataDictionary {
                    ["A"] = a
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                IReadOnlyList <IDocument> result = metadata.DocumentList("A");

                // Then
                Assert.IsNotNull(result);
                CollectionAssert.AreEqual(new[] { a }, result);
            }
コード例 #10
0
        // Metadata:
        //[0] long 7 536870912,
        //[1] int 2 1,
        //[2] int 2 0,
        //[3] byte 0 0,
        //[4] string 4 ,
        //[5] long 7 1,
        //[6] long 7 0,
        //[7] short 1 300,
        //[8] int 2 0,
        //[9] byte 0 0,
        //[38] long 7 0,
        //[39] float 3 1,
        //[44] short 1 300,
        //[45] int 2 0,
        //[46] byte 0 0,
        //[47] int 2 0,
        //[53] float 3 1,99,
        //[54] float 3 1,99,
        //[56] vector3 8 <0� 0� 0>,
        //[57] byte 0 0,
        //[58] float 3 0,
        //[59] float 3 0

        public override MetadataDictionary GetMetadata()
        {
            MetadataDictionary metadata = base.GetMetadata();

            //MetadataDictionary metadata = new MetadataDictionary();
            metadata[0]  = new MetadataLong(GetDataValue());
            metadata[39] = new MetadataFloat(1.0f);
            metadata[44] = new MetadataShort(300);
            metadata[53] = new MetadataFloat(1.99f);
            metadata[54] = new MetadataFloat(1.99f);
            metadata[57] = new MetadataByte(0);
            metadata[58] = new MetadataFloat(0);
            metadata[59] = new MetadataFloat(0);

            return(metadata);
        }
コード例 #11
0
ファイル: Wither.cs プロジェクト: kennyvv/MiNET-1.2
        public override MetadataDictionary GetMetadata()
        {
            MetadataDictionary metadata = new MetadataDictionary();

            metadata[0]  = new MetadataLong(8592556032);            // 1000000000001010000000000000000000; CanClimb, CanFly, Breathing
            metadata[1]  = new MetadataInt(1);
            metadata[2]  = new MetadataInt(0);
            metadata[3]  = new MetadataByte(0);
            metadata[4]  = new MetadataString("");
            metadata[5]  = new MetadataLong(-1);
            metadata[7]  = new MetadataShort(300);
            metadata[8]  = new MetadataInt(0);
            metadata[9]  = new MetadataByte(0);
            metadata[10] = new MetadataByte(0);
            metadata[22] = new MetadataByte(0);
            metadata[38] = new MetadataLong(0);
            metadata[39] = new MetadataFloat(1f);
            metadata[43] = new MetadataShort(300);
            metadata[44] = new MetadataInt(0);
            metadata[45] = new MetadataByte(0);
            metadata[46] = new MetadataInt(0);
            metadata[47] = new MetadataInt(0);
            metadata[49] = new MetadataInt(AnimationStep);
            metadata[50] = new MetadataLong(-1);
            metadata[51] = new MetadataLong(-1);
            metadata[52] = new MetadataLong(-1);
            metadata[53] = new MetadataShort((short)(ShowAuora ? 0 : 1));
            metadata[54] = new MetadataFloat(1f);
            metadata[55] = new MetadataFloat(3f);
            metadata[58] = new MetadataByte(0);
            metadata[59] = new MetadataFloat(0f);
            metadata[60] = new MetadataFloat(0f);
            metadata[70] = new MetadataByte(0);
            metadata[71] = new MetadataString("");
            metadata[72] = new MetadataString("");
            metadata[73] = new MetadataByte(1);
            metadata[74] = new MetadataByte(0);
            metadata[75] = new MetadataInt(0);
            metadata[76] = new MetadataInt(0);
            metadata[77] = new MetadataInt(0);
            metadata[78] = new MetadataInt(-1);

            //metadata[49] = new MetadataInt(0);
            //metadata[53] = new MetadataShort(0);

            return(metadata);
        }
コード例 #12
0
        public void Initialize(MetadataDictionary metadata, SettingsDictionary settings)
        {
            if (string.IsNullOrEmpty(settings["ApplyGain"]) ||
                string.Compare(settings["ApplyGain"], bool.FalseString, StringComparison.OrdinalIgnoreCase) == 0)
            {
                return;
            }

            if (string.Compare(settings["ApplyGain"], "Album", StringComparison.OrdinalIgnoreCase) == 0)
            {
                if (string.IsNullOrEmpty(metadata["AlbumGain"]))
                {
                    throw new InvalidSettingException(Resources.ReplayGainSampleFilterMissingAlbumGain);
                }
                if (string.IsNullOrEmpty(metadata["AlbumPeak"]))
                {
                    throw new InvalidSettingException(Resources.ReplayGainSampleFilterMissingAlbumPeak);
                }

                _scale = CalculateScale(metadata["AlbumGain"], metadata["AlbumPeak"]);
            }
            else if (string.Compare(settings["ApplyGain"], "Track", StringComparison.OrdinalIgnoreCase) == 0)
            {
                if (string.IsNullOrEmpty(metadata["TrackGain"]))
                {
                    throw new InvalidSettingException(Resources.ReplayGainSampleFilterMissingTrackGain);
                }
                if (string.IsNullOrEmpty(metadata["TrackPeak"]))
                {
                    throw new InvalidSettingException(Resources.ReplayGainSampleFilterMissingTrackPeak);
                }

                _scale = CalculateScale(metadata["TrackGain"], metadata["TrackPeak"]);
            }
            else
            {
                throw new InvalidSettingException(string.Format(CultureInfo.CurrentCulture,
                                                                Resources.ReplayGainSampleFilterBadApplyGain, settings["ApplyGain"]));
            }

            // Adjust the metadata so that it remains valid:
            metadata["AlbumGain"] = AdjustGain(metadata["AlbumGain"], _scale);
            metadata["TrackGain"] = AdjustGain(metadata["TrackGain"], _scale);
            metadata["AlbumPeak"] = AdjustPeak(metadata["AlbumPeak"], _scale);
            metadata["TrackPeak"] = AdjustPeak(metadata["TrackPeak"], _scale);
        }
コード例 #13
0
        public void Initialize(Stream stream, AudioInfo audioInfo, MetadataDictionary metadata, SettingsDictionary settings)
        {
            Contract.Ensures(_writer != null);
            Contract.Ensures(_writer.BaseStream == stream);
            Contract.Ensures(_channels == audioInfo.Channels);
            Contract.Ensures(_bytesPerSample > 0);
            Contract.Ensures(_multiplier > 0);

            _writer         = new RiffWriter(stream, "WAVE");
            _channels       = audioInfo.Channels;
            _bytesPerSample = (int)Math.Ceiling(audioInfo.BitsPerSample / (double)8);
            _multiplier     = (float)Math.Pow(2, audioInfo.BitsPerSample - 1);

            _writer.Initialize();
            WriteFmtChunk(_writer, audioInfo, _bytesPerSample);
            _writer.BeginChunk("data");
        }
コード例 #14
0
        public void ApplyMetadataChanges(int id, MetadataDictionary mc)
        {
            DataSet targetDS = Target;

            if (targetDS != null)
            {
                int targetID;
                if (targetVars.TryGetValue(id, out targetID))
                {
                    Variable v = targetDS.Variables.GetByID(targetID);
                    foreach (var p in mc)
                    {
                        v.Metadata[p.Key] = p.Value;
                    }
                }
            }
        }
コード例 #15
0
            public void ReturnsCorrectResultForKeysWithDifferentCase()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary
                {
                    ["A"] = new SimpleMetadataValue {
                        Value = "a"
                    }
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                object value = metadata["a"];

                // Then
                Assert.AreEqual("a", value);
            }
コード例 #16
0
            public void ReturnsCorrectResultForConvertedIntList()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary {
                    ["A"] = new List <int> {
                        1, 2, 3
                    }
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                IReadOnlyList <string> result = metadata.List <string>("A");

                // Then
                Assert.IsNotNull(result);
                CollectionAssert.AreEqual(result, new[] { "1", "2", "3" });
            }
コード例 #17
0
            public void ReturnsEmptyListForListOfInt()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary {
                    ["A"] = new List <int> {
                        1, 2, 3
                    }
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                IReadOnlyList <IDocument> result = metadata.DocumentList("A");

                // Then
                Assert.IsNotNull(result);
                CollectionAssert.IsEmpty(result);
            }
コード例 #18
0
            public void ReplacesValue()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary {
                    ["A"] = "a"
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                MetadataStack clone = metadata.Clone(new Dictionary <string, object> {
                    { "A", "b" }
                });

                // Then
                Assert.AreEqual("a", metadata["A"]);
                Assert.AreEqual("b", clone["A"]);
            }
コード例 #19
0
        public override MetadataDictionary GetMetadata()
        {
            MetadataDictionary metadata = new MetadataDictionary();

            metadata[0]  = new MetadataByte((byte)(HealthManager.IsOnFire ? 1 : 0));
            metadata[1]  = new MetadataShort(HealthManager.Air);
            metadata[2]  = new MetadataString(NameTag ?? Name);
            metadata[3]  = new MetadataByte(!HideNameTag);
            metadata[4]  = new MetadataByte(Silent);
            metadata[7]  = new MetadataInt(0);            // Potion Color
            metadata[8]  = new MetadataByte(0);           // Potion Ambient
            metadata[15] = new MetadataByte(NoAi);
            metadata[16] = new MetadataByte(0);           // Player flags
            metadata[17] = new MetadataLong(0);

            return(metadata);
        }
コード例 #20
0
        public virtual MetadataDictionary GetMetadata()
        {
            MetadataDictionary metadata = new MetadataDictionary();

            metadata[0]  = new MetadataByte(GetDataValue());
            metadata[2]  = new MetadataString(NameTag ?? string.Empty);
            metadata[3]  = new MetadataByte(!HideNameTag);
            metadata[4]  = new MetadataByte(Silent);
            metadata[7]  = new MetadataInt(0);            // Potion Color
            metadata[8]  = new MetadataByte(0);           // Potion Ambient
            metadata[15] = new MetadataByte(NoAi);
            metadata[16] = new MetadataByte(0);           // Player flags
            //metadata[17] = new MetadataIntCoordinates(0, 0, 0);
            metadata[23] = new MetadataLong(-1);          // Leads EID (target or holder?)
            metadata[24] = new MetadataByte(0);           // Leads on/off
            return(metadata);
        }
コード例 #21
0
        internal MetadataToVorbisCommentAdapter(MetadataDictionary metadata)
        {
            Contract.Requires(metadata != null);

            var day   = 0;
            var month = 0;
            var year  = 0;

            foreach (var item in metadata)
            {
                switch (item.Key)
                {
                case "Day":
                    day = int.Parse(item.Value, CultureInfo.InvariantCulture);
                    break;

                case "Month":
                    month = int.Parse(item.Value, CultureInfo.InvariantCulture);
                    break;

                case "Year":
                    year = int.Parse(item.Value, CultureInfo.InvariantCulture);
                    break;

                default:
                    string mappedKey;
                    if (_map.TryGetValue(item.Key, out mappedKey))
                    {
                        this[mappedKey] = item.Value;
                    }
                    break;
                }
            }

            // The DATE field should contain either a full date, or just the year:
            if (day > 0 && month > 0 && year > 0)
            {
                Contract.Assume(month <= 12);

                this["DATE"] = new DateTime(year, month, day).ToShortDateString();
            }
            else if (year > 0)
            {
                this["DATE"] = year.ToString(CultureInfo.InvariantCulture);
            }
        }
コード例 #22
0
ファイル: Dragon.cs プロジェクト: apieceofcaken/MiNET
        public override MetadataDictionary GetMetadata()
        {
            Log.Warn("Metadata");
            MetadataDictionary metadata = new MetadataDictionary();

            //metadata[38] = new MetadataLong(0);
            //metadata[39] = new MetadataFloat(1f);
            //metadata[44] = new MetadataShort(300);

            //MetadataDictionary metadata = new MetadataDictionary();
            metadata[0]  = new MetadataLong(8388608);            // 100000000000000000000000; Sitting
            metadata[1]  = new MetadataInt(1);
            metadata[2]  = new MetadataInt(0);
            metadata[3]  = new MetadataByte(0);
            metadata[4]  = new MetadataString("");
            metadata[5]  = new MetadataLong(-1);
            metadata[7]  = new MetadataShort(300);
            metadata[8]  = new MetadataInt(0);
            metadata[9]  = new MetadataByte(0);
            metadata[10] = new MetadataByte(0);
            metadata[22] = new MetadataByte(0);
            metadata[38] = new MetadataLong(0);
            metadata[39] = new MetadataFloat(1f);
            metadata[43] = new MetadataShort(300);
            metadata[44] = new MetadataInt(0);
            metadata[45] = new MetadataByte(0);
            metadata[46] = new MetadataInt(0);
            metadata[47] = new MetadataInt(0);
            metadata[54] = new MetadataFloat(13f);
            metadata[55] = new MetadataFloat(4f);
            metadata[58] = new MetadataByte(0);
            metadata[59] = new MetadataFloat(0f);
            metadata[60] = new MetadataFloat(0f);
            metadata[70] = new MetadataByte(0);
            metadata[71] = new MetadataString("");
            metadata[72] = new MetadataString("");
            metadata[73] = new MetadataByte(1);
            metadata[74] = new MetadataByte(0);
            metadata[75] = new MetadataInt(0);
            metadata[76] = new MetadataInt(0);
            metadata[77] = new MetadataInt(0);
            metadata[78] = new MetadataInt(-1);

            return(metadata);
        }
コード例 #23
0
        void WriteHeader(MetadataDictionary metadata, Stream stream)
        {
            Contract.Requires(metadata != null);
            Contract.Requires(stream != null);
            Contract.Requires(stream.CanWrite);

            var vorbisComment = new VorbisComment();

            try
            {
                SafeNativeMethods.VorbisCommentInitialize(out vorbisComment);

                foreach (var item in new MetadataToVorbisCommentAdapter(metadata))
                {
                    // The key and value need to be marshaled as null-terminated UTF-8 strings:
                    var keyBytes = new byte[Encoding.UTF8.GetByteCount(item.Key) + 1];
                    Encoding.UTF8.GetBytes(item.Key, 0, item.Key.Length, keyBytes, 0);

                    var valueBytes = new byte[Encoding.UTF8.GetByteCount(item.Value) + 1];
                    Encoding.UTF8.GetBytes(item.Value, 0, item.Value.Length, valueBytes, 0);

                    SafeNativeMethods.VorbisCommentAddTag(ref vorbisComment, keyBytes, valueBytes);
                }

                OggPacket first;
                OggPacket second;
                OggPacket third;
                _encoder.HeaderOut(ref vorbisComment, out first, out second, out third);

                _oggStream.PacketIn(ref first);
                _oggStream.PacketIn(ref second);
                _oggStream.PacketIn(ref third);
            }
            finally
            {
                SafeNativeMethods.VorbisCommentClear(ref vorbisComment);
            }

            OggPage page;

            while (_oggStream.Flush(out page))
            {
                WritePage(page, stream);
            }
        }
コード例 #24
0
        public MetadataDictionary GetResult()
        {
            Contract.Ensures(Contract.Result <MetadataDictionary>() != null);

            var result = new MetadataDictionary
            {
                ["TrackPeak"] = ConvertPeakToString(_analyzer.GetSamplePeak()),
                ["TrackGain"] = ConvertGainToString(_referenceLevel - _analyzer.GetLoudness())
            };

            _groupToken.CompleteMember();
            _groupToken.WaitForMembers();

            result["AlbumPeak"] = ConvertPeakToString(_analyzer.GetSamplePeakMultiple());
            result["AlbumGain"] = ConvertGainToString(_referenceLevel - _analyzer.GetLoudnessMultiple());

            return(result);
        }
コード例 #25
0
            public void IMetadataConvertsToIDocument()
            {
                // Given
                IMetadata value = new MetadataDictionary
                {
                    { "Foo", "bar" },
                    { "A", 1 }
                };

                // When
                bool convert = TypeHelper.TryConvert(value, out IDocument result);

                // Then
                convert.ShouldBeTrue();
                result.ShouldNotBeNull();
                result["Foo"].ShouldBe("bar");
                result["A"].ShouldBe(1);
            }
コード例 #26
0
            public void ReturnsCorrectResultWithDerivedMetadataValue()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary
                {
                    ["A"] = new DerivedMetadataValue {
                        Key = "X"
                    },
                    ["X"] = "x"
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                object value = metadata.Get("A");

                // Then
                Assert.AreEqual("x", value);
            }
コード例 #27
0
        private void HandleUseItem(McpeUseItem message)
        {
            Log.DebugFormat("Use item: {0}", message.item);
            Log.DebugFormat("Entity ID: {0}", message.entityId);
            Log.DebugFormat("meta:  {0}", message.meta);
            Log.DebugFormat("x:  {0}", message.x);
            Log.DebugFormat("y:  {0}", message.y);
            Log.DebugFormat("z:  {0}", message.z);
            Log.DebugFormat("face:  {0}", message.face);
            Log.DebugFormat("fx:  {0}", message.fx);
            Log.DebugFormat("fy:  {0}", message.fy);
            Log.DebugFormat("fz:  {0}", message.fz);
            Log.DebugFormat("px:  {0}", message.positionX);
            Log.DebugFormat("py:  {0}", message.positionY);
            Log.DebugFormat("pz:  {0}", message.positionZ);

            if (message.face <= 5)
            {
                Level.RelayBroadcast(this, new McpeAnimate()
                {
                    actionId = 1,
                    entityId = EntityId
                });

                Vector3 faceCoords = new Vector3(message.fx, message.fy, message.fz);

                Level.Interact(Level, this, message.item, new BlockCoordinates(message.x, message.y, message.z), message.meta, (BlockFace)message.face, faceCoords);
            }
            else
            {
                _itemUseTimer = new Stopwatch();
                _itemUseTimer.Start();
                // Snowballs and shit
                Level.Interact(Level, this, message.item, new BlockCoordinates(message.x, message.y, message.z), message.meta);

                MetadataDictionary metadata = new MetadataDictionary();
                metadata[0] = new MetadataByte(16);
                Level.RelayBroadcast(this, new McpeSetEntityData
                {
                    entityId = EntityId,
                    metadata = metadata,
                });
            }
        }
コード例 #28
0
            public void ReturnsCorrectResultWithMetadataValue()
            {
                // Given
                MetadataDictionary initialMetadata = new MetadataDictionary
                {
                    ["A"] = new SimpleMetadataValue {
                        Value = "a"
                    }
                };
                MetadataStack metadata = new MetadataStack(initialMetadata);

                // When
                object value;
                bool   contains = metadata.TryGetValue("A", out value);

                // Then
                Assert.IsTrue(contains);
                Assert.AreEqual("a", value);
            }
コード例 #29
0
ファイル: PlayerMob.cs プロジェクト: GoldishKirby/MiNET
        public override MetadataDictionary GetMetadata()
        {
            MetadataDictionary metadata = new MetadataDictionary();

            metadata[0]  = new MetadataByte((byte)(HealthManager.IsOnFire ? 1 : 0));
            metadata[1]  = new MetadataShort(HealthManager.Air);
            metadata[2]  = new MetadataString(NameTag ?? Name);
            metadata[3]  = new MetadataByte(!HideNameTag);
            metadata[4]  = new MetadataByte(Silent);
            metadata[7]  = new MetadataInt(0);            // Potion Color
            metadata[8]  = new MetadataByte(0);           // Potion Ambient
            metadata[15] = new MetadataByte(NoAi);
            metadata[16] = new MetadataByte(0);           // Player flags
            //metadata[17] = new MetadataIntCoordinates(0, 0, 0);
            metadata[23] = new MetadataInt(-1);           // Leads EID (target or holder?)
            metadata[24] = new MetadataByte(0);           // Leads on/off

            return(metadata);
        }
コード例 #30
0
 static void PrintMetadata(MetadataDictionary metadata)
 {
     foreach (var item in metadata)
     {
         Console.Write("{0,20} =", item.Key);
         if (item.Value is IEnumerable && !(item.Value is string))
         {
             foreach (var value in item.Value as IEnumerable)
             {
                 Console.Write(" {0}", value);
             }
         }
         else
         {
             Console.Write(" {0}", item.Value);
         }
         Console.WriteLine();
     }
 }
コード例 #31
0
        static byte[] GenerateIlst(Mp4 originalMp4, MetadataDictionary metadata, SettingsDictionary settings)
        {
            Contract.Requires(originalMp4 != null);
            Contract.Requires(metadata != null);
            Contract.Requires(settings != null);
            Contract.Ensures(Contract.Result <byte[]>() != null);

            using (var resultStream = new MemoryStream())
            {
                var adaptedMetadata = new MetadataToAtomAdapter(metadata, settings);

                // "Reverse DNS" atoms may need to be preserved:
                foreach (ReverseDnsAtom reverseDnsAtom in
                         from listAtom in originalMp4.GetChildAtomInfo()
                         where listAtom.FourCC == "----"
                         select new ReverseDnsAtom(originalMp4.ReadAtom(listAtom)))
                {
                    switch (reverseDnsAtom.Name)
                    {
                    // Always preserve the iTunSMPB (gapless playback) atom:
                    case "iTunSMPB":
                        resultStream.Write(reverseDnsAtom.GetBytes(), 0, reverseDnsAtom.GetBytes().Length);
                        break;

                    // Preserve the existing iTunNORM atom if a new one isn't provided, and AddSoundCheck isn't explicitly False:
                    case "iTunNORM":
                        if (!adaptedMetadata.IncludesSoundCheck &&
                            string.Compare(settings["AddSoundCheck"], bool.FalseString,
                                           StringComparison.OrdinalIgnoreCase) != 0)
                        {
                            resultStream.Write(reverseDnsAtom.GetBytes(), 0, reverseDnsAtom.GetBytes().Length);
                        }
                        break;
                    }
                }

                byte[] atomData = adaptedMetadata.GetBytes();
                resultStream.Write(atomData, 0, atomData.Length);

                return(resultStream.ToArray());
            }
        }
コード例 #32
0
ファイル: Entity.cs プロジェクト: oas/MiNET
        public virtual MetadataDictionary GetMetadata()
        {
            MetadataDictionary metadata = new MetadataDictionary();

            metadata[(int)MetadataFlags.EntityFlags] = new MetadataLong(GetDataValue());
            metadata[1] = new MetadataInt(1);
            metadata[(int)MetadataFlags.HideNameTag]         = new MetadataByte(!HideNameTag);
            metadata[(int)MetadataFlags.NameTag]             = new MetadataString(NameTag ?? string.Empty);
            metadata[(int)MetadataFlags.AvailableAir]        = new MetadataShort(HealthManager.Air);
            metadata[(int)MetadataFlags.PotionColor]         = new MetadataInt(PotionColor);
            metadata[(int)MetadataFlags.Scale]               = new MetadataFloat(Scale); // Scale
            metadata[(int)MetadataFlags.MaxAir]              = new MetadataShort(HealthManager.MaxAir);
            metadata[(int)MetadataFlags.RiderSeatPosition]   = new MetadataVector3(RiderSeatPosition);
            metadata[(int)MetadataFlags.RiderRotationLocked] = new MetadataByte(RiderRotationLocked);
            metadata[(int)MetadataFlags.RiderMaxRotation]    = new MetadataFloat(RiderMaxRotation);
            metadata[(int)MetadataFlags.RiderMinRotation]    = new MetadataFloat(RiderMinRotation);
            metadata[(int)MetadataFlags.CollisionBoxHeight]  = new MetadataFloat(Height);           // Collision box width
            metadata[(int)MetadataFlags.CollisionBoxWidth]   = new MetadataFloat(Width);            // Collision box height
            return(metadata);
        }
コード例 #33
0
ファイル: Program.cs プロジェクト: modulexcite/SDSlite
 static void PrintMetadata(MetadataDictionary metadata)
 {
     foreach (var item in metadata)
     {
         Console.Write("{0,20} =", item.Key);
         if (item.Value is IEnumerable && !(item.Value is string))
             foreach (var value in item.Value as IEnumerable)
                 Console.Write(" {0}", value);
         else
             Console.Write(" {0}", item.Value);
         Console.WriteLine();
     }
 }
コード例 #34
0
		internal MetadataDictionary FilterChanges(MetadataDictionary metadata)
		{
			MetadataDictionary md = new MetadataDictionary();
			if (metadata.Count == 0 && !metadata.HasChanges)
				return md;

			Dictionary<string, object> dict = metadata.AsDictionary(SchemaVersion.Recent);
			foreach (var item in dict)
			{
				if (!IsHiddenEntry(item.Key))
				{
					md[item.Key] = item.Value;
				}
			}
			return md;
		}