提交Unity 联机Pro

JNFrame2/Assets/Plugins/SRF/External/Jetbrains.Annotations.cs

@@ -0,0 +1,938 @@
+
+#if !UNITY_5 && !UNITY_5_3_OR_NEWER && UNITY_EDITOR
+
+using System;
+using System.Diagnostics;
+
+#pragma warning disable 1591
+// ReSharper disable UnusedMember.Global
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable UnusedAutoPropertyAccessor.Global
+// ReSharper disable IntroduceOptionalParameters.Global
+// ReSharper disable MemberCanBeProtected.Global
+// ReSharper disable InconsistentNaming
+
+namespace JetBrains.Annotations
+{
+	/// <summary>
+	/// Indicates that the value of the marked element could be <c>null</c> sometimes,
+	/// so the check for <c>null</c> is necessary before its usage
+	/// </summary>
+	/// <example><code>
+	/// [CanBeNull] public object Test() { return null; }
+	/// public void UseTest() {
+	///   var p = Test();
+	///   var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
+	/// }
+	/// </code></example>
+	[AttributeUsage(
+	  AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+	  AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class CanBeNullAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that the value of the marked element could never be <c>null</c>
+	/// </summary>
+	/// <example><code>
+	/// [NotNull] public object Foo() {
+	///   return null; // Warning: Possible 'null' assignment
+	/// }
+	/// </code></example>
+	[AttributeUsage(
+	  AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+	  AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class NotNullAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that collection or enumerable value does not contain null elements
+	/// </summary>
+	[AttributeUsage(
+	  AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+	  AttributeTargets.Delegate | AttributeTargets.Field)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class ItemNotNullAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that collection or enumerable value can contain null elements
+	/// </summary>
+	[AttributeUsage(
+	  AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+	  AttributeTargets.Delegate | AttributeTargets.Field)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class ItemCanBeNullAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that the marked method builds string by format pattern and (optional) arguments.
+	/// Parameter, which contains format string, should be given in constructor. The format string
+	/// should be in <see cref="string.Format(IFormatProvider,string,object[])"/>-like form
+	/// </summary>
+	/// <example><code>
+	/// [StringFormatMethod("message")]
+	/// public void ShowError(string message, params object[] args) { /* do something */ }
+	/// public void Foo() {
+	///   ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
+	/// }
+	/// </code></example>
+	[AttributeUsage(
+	  AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Delegate)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class StringFormatMethodAttribute : Attribute
+	{
+		/// <param name="formatParameterName">
+		/// Specifies which parameter of an annotated method should be treated as format-string
+		/// </param>
+		public StringFormatMethodAttribute(string formatParameterName)
+		{
+			FormatParameterName = formatParameterName;
+		}
+
+		public string FormatParameterName { get; private set; }
+	}
+
+	/// <summary>
+	/// For a parameter that is expected to be one of the limited set of values.
+	/// Specify fields of which type should be used as values for this parameter.
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class ValueProviderAttribute : Attribute
+	{
+		public ValueProviderAttribute(string name)
+		{
+			Name = name;
+		}
+
+		[NotNull]
+		public string Name { get; private set; }
+	}
+
+	/// <summary>
+	/// Indicates that the function argument should be string literal and match one
+	/// of the parameters of the caller function. For example, ReSharper annotates
+	/// the parameter of <see cref="System.ArgumentNullException"/>
+	/// </summary>
+	/// <example><code>
+	/// public void Foo(string param) {
+	///   if (param == null)
+	///     throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
+	/// }
+	/// </code></example>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class InvokerParameterNameAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that the method is contained in a type that implements
+	/// <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
+	/// is used to notify that some property value changed
+	/// </summary>
+	/// <remarks>
+	/// The method should be non-static and conform to one of the supported signatures:
+	/// <list>
+	/// <item><c>NotifyChanged(string)</c></item>
+	/// <item><c>NotifyChanged(params string[])</c></item>
+	/// <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
+	/// <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
+	/// <item><c>SetProperty{T}(ref T, T, string)</c></item>
+	/// </list>
+	/// </remarks>
+	/// <example><code>
+	/// public class Foo : INotifyPropertyChanged {
+	///   public event PropertyChangedEventHandler PropertyChanged;
+	///   [NotifyPropertyChangedInvocator]
+	///   protected virtual void NotifyChanged(string propertyName) { ... }
+	///
+	///   private string _name;
+	///   public string Name {
+	///     get { return _name; }
+	///     set { _name = value; NotifyChanged("LastName"); /* Warning */ }
+	///   }
+	/// }
+	/// </code>
+	/// Examples of generated notifications:
+	/// <list>
+	/// <item><c>NotifyChanged("Property")</c></item>
+	/// <item><c>NotifyChanged(() =&gt; Property)</c></item>
+	/// <item><c>NotifyChanged((VM x) =&gt; x.Property)</c></item>
+	/// <item><c>SetProperty(ref myField, value, "Property")</c></item>
+	/// </list>
+	/// </example>
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
+	{
+		public NotifyPropertyChangedInvocatorAttribute() { }
+		public NotifyPropertyChangedInvocatorAttribute(string parameterName)
+		{
+			ParameterName = parameterName;
+		}
+
+		public string ParameterName { get; private set; }
+	}
+
+	/// <summary>
+	/// Describes dependency between method input and output
+	/// </summary>
+	/// <syntax>
+	/// <p>Function Definition Table syntax:</p>
+	/// <list>
+	/// <item>FDT      ::= FDTRow [;FDTRow]*</item>
+	/// <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
+	/// <item>Input    ::= ParameterName: Value [, Input]*</item>
+	/// <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
+	/// <item>Value    ::= true | false | null | notnull | canbenull</item>
+	/// </list>
+	/// If method has single input parameter, it's name could be omitted.<br/>
+	/// Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same)
+	/// for method output means that the methos doesn't return normally.<br/>
+	/// <c>canbenull</c> annotation is only applicable for output parameters.<br/>
+	/// You can use multiple <c>[ContractAnnotation]</c> for each FDT row,
+	/// or use single attribute with rows separated by semicolon.<br/>
+	/// </syntax>
+	/// <examples><list>
+	/// <item><code>
+	/// [ContractAnnotation("=> halt")]
+	/// public void TerminationMethod()
+	/// </code></item>
+	/// <item><code>
+	/// [ContractAnnotation("halt &lt;= condition: false")]
+	/// public void Assert(bool condition, string text) // regular assertion method
+	/// </code></item>
+	/// <item><code>
+	/// [ContractAnnotation("s:null => true")]
+	/// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
+	/// </code></item>
+	/// <item><code>
+	/// // A method that returns null if the parameter is null,
+	/// // and not null if the parameter is not null
+	/// [ContractAnnotation("null => null; notnull => notnull")]
+	/// public object Transform(object data) 
+	/// </code></item>
+	/// <item><code>
+	/// [ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")]
+	/// public bool TryParse(string s, out Person result)
+	/// </code></item>
+	/// </list></examples>
+	[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class ContractAnnotationAttribute : Attribute
+	{
+		public ContractAnnotationAttribute([NotNull] string contract)
+			: this(contract, false) { }
+
+		public ContractAnnotationAttribute([NotNull] string contract, bool forceFullStates)
+		{
+			Contract = contract;
+			ForceFullStates = forceFullStates;
+		}
+
+		public string Contract { get; private set; }
+		public bool ForceFullStates { get; private set; }
+	}
+
+	/// <summary>
+	/// Indicates that marked element should be localized or not
+	/// </summary>
+	/// <example><code>
+	/// [LocalizationRequiredAttribute(true)]
+	/// public class Foo {
+	///   private string str = "my string"; // Warning: Localizable string
+	/// }
+	/// </code></example>
+	[AttributeUsage(AttributeTargets.All)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class LocalizationRequiredAttribute : Attribute
+	{
+		public LocalizationRequiredAttribute() : this(true) { }
+		public LocalizationRequiredAttribute(bool required)
+		{
+			Required = required;
+		}
+
+		public bool Required { get; private set; }
+	}
+
+	/// <summary>
+	/// Indicates that the value of the marked type (or its derivatives)
+	/// cannot be compared using '==' or '!=' operators and <c>Equals()</c>
+	/// should be used instead. However, using '==' or '!=' for comparison
+	/// with <c>null</c> is always permitted.
+	/// </summary>
+	/// <example><code>
+	/// [CannotApplyEqualityOperator]
+	/// class NoEquality { }
+	/// class UsesNoEquality {
+	///   public void Test() {
+	///     var ca1 = new NoEquality();
+	///     var ca2 = new NoEquality();
+	///     if (ca1 != null) { // OK
+	///       bool condition = ca1 == ca2; // Warning
+	///     }
+	///   }
+	/// }
+	/// </code></example>
+	[AttributeUsage(
+	  AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class CannotApplyEqualityOperatorAttribute : Attribute { }
+
+	/// <summary>
+	/// When applied to a target attribute, specifies a requirement for any type marked
+	/// with the target attribute to implement or inherit specific type or types.
+	/// </summary>
+	/// <example><code>
+	/// [BaseTypeRequired(typeof(IComponent)] // Specify requirement
+	/// public class ComponentAttribute : Attribute { }
+	/// [Component] // ComponentAttribute requires implementing IComponent interface
+	/// public class MyComponent : IComponent { }
+	/// </code></example>
+	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+	[BaseTypeRequired(typeof(Attribute))]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class BaseTypeRequiredAttribute : Attribute
+	{
+		public BaseTypeRequiredAttribute([NotNull] Type baseType)
+		{
+			BaseType = baseType;
+		}
+
+		[NotNull]
+		public Type BaseType { get; private set; }
+	}
+
+	/// <summary>
+	/// Indicates that the marked symbol is used implicitly
+	/// (e.g. via reflection, in external library), so this symbol
+	/// will not be marked as unused (as well as by other usage inspections)
+	/// </summary>
+	[AttributeUsage(AttributeTargets.All)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class UsedImplicitlyAttribute : Attribute
+	{
+		public UsedImplicitlyAttribute()
+			: this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { }
+
+		public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
+			: this(useKindFlags, ImplicitUseTargetFlags.Default) { }
+
+		public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags)
+			: this(ImplicitUseKindFlags.Default, targetFlags) { }
+
+		public UsedImplicitlyAttribute(
+		  ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
+		{
+			UseKindFlags = useKindFlags;
+			TargetFlags = targetFlags;
+		}
+
+		public ImplicitUseKindFlags UseKindFlags { get; private set; }
+		public ImplicitUseTargetFlags TargetFlags { get; private set; }
+	}
+
+	/// <summary>
+	/// Should be used on attributes and causes ReSharper
+	/// to not mark symbols marked with such attributes as unused
+	/// (as well as by other usage inspections)
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class MeansImplicitUseAttribute : Attribute
+	{
+		public MeansImplicitUseAttribute()
+			: this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { }
+
+		public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
+			: this(useKindFlags, ImplicitUseTargetFlags.Default) { }
+
+		public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags)
+			: this(ImplicitUseKindFlags.Default, targetFlags) { }
+
+		public MeansImplicitUseAttribute(
+		  ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
+		{
+			UseKindFlags = useKindFlags;
+			TargetFlags = targetFlags;
+		}
+
+		[UsedImplicitly]
+		public ImplicitUseKindFlags UseKindFlags { get; private set; }
+		[UsedImplicitly]
+		public ImplicitUseTargetFlags TargetFlags { get; private set; }
+	}
+
+	[Flags]
+	public enum ImplicitUseKindFlags
+	{
+		Default = Access | Assign | InstantiatedWithFixedConstructorSignature,
+		/// <summary>Only entity marked with attribute considered used</summary>
+		Access = 1,
+		/// <summary>Indicates implicit assignment to a member</summary>
+		Assign = 2,
+		/// <summary>
+		/// Indicates implicit instantiation of a type with fixed constructor signature.
+		/// That means any unused constructor parameters won't be reported as such.
+		/// </summary>
+		InstantiatedWithFixedConstructorSignature = 4,
+		/// <summary>Indicates implicit instantiation of a type</summary>
+		InstantiatedNoFixedConstructorSignature = 8,
+	}
+
+	/// <summary>
+	/// Specify what is considered used implicitly when marked
+	/// with <see cref="MeansImplicitUseAttribute"/> or <see cref="UsedImplicitlyAttribute"/>
+	/// </summary>
+	[Flags]
+	public enum ImplicitUseTargetFlags
+	{
+		Default = Itself,
+		Itself = 1,
+		/// <summary>Members of entity marked with attribute are considered used</summary>
+		Members = 2,
+		/// <summary>Entity marked with attribute and all its members considered used</summary>
+		WithMembers = Itself | Members
+	}
+
+	/// <summary>
+	/// This attribute is intended to mark publicly available API
+	/// which should not be removed and so is treated as used
+	/// </summary>
+	[MeansImplicitUse]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class PublicAPIAttribute : Attribute
+	{
+		public PublicAPIAttribute() { }
+		public PublicAPIAttribute([NotNull] string comment)
+		{
+			Comment = comment;
+		}
+
+		public string Comment { get; private set; }
+	}
+
+	/// <summary>
+	/// Tells code analysis engine if the parameter is completely handled
+	/// when the invoked method is on stack. If the parameter is a delegate,
+	/// indicates that delegate is executed while the method is executed.
+	/// If the parameter is an enumerable, indicates that it is enumerated
+	/// while the method is executed
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class InstantHandleAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that a method does not make any observable state changes.
+	/// The same as <c>System.Diagnostics.Contracts.PureAttribute</c>
+	/// </summary>
+	/// <example><code>
+	/// [Pure] private int Multiply(int x, int y) { return x * y; }
+	/// public void Foo() {
+	///   const int a = 2, b = 2;
+	///   Multiply(a, b); // Waring: Return value of pure method is not used
+	/// }
+	/// </code></example>
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class PureAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that a parameter is a path to a file or a folder within a web project.
+	/// Path can be relative or absolute, starting from web root (~)
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public class PathReferenceAttribute : Attribute
+	{
+		public PathReferenceAttribute() { }
+		public PathReferenceAttribute([PathReference] string basePath)
+		{
+			BasePath = basePath;
+		}
+
+		public string BasePath { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute
+	{
+		public AspMvcAreaMasterLocationFormatAttribute(string format)
+		{
+			Format = format;
+		}
+
+		public string Format { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute
+	{
+		public AspMvcAreaPartialViewLocationFormatAttribute(string format)
+		{
+			Format = format;
+		}
+
+		public string Format { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute
+	{
+		public AspMvcAreaViewLocationFormatAttribute(string format)
+		{
+			Format = format;
+		}
+
+		public string Format { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcMasterLocationFormatAttribute : Attribute
+	{
+		public AspMvcMasterLocationFormatAttribute(string format)
+		{
+			Format = format;
+		}
+
+		public string Format { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute
+	{
+		public AspMvcPartialViewLocationFormatAttribute(string format)
+		{
+			Format = format;
+		}
+
+		public string Format { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcViewLocationFormatAttribute : Attribute
+	{
+		public AspMvcViewLocationFormatAttribute(string format)
+		{
+			Format = format;
+		}
+
+		public string Format { get; private set; }
+	}
+
+	/// <summary>
+	/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+	/// is an MVC action. If applied to a method, the MVC action name is calculated
+	/// implicitly from the context. Use this attribute for custom wrappers similar to
+	/// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcActionAttribute : Attribute
+	{
+		public AspMvcActionAttribute() { }
+		public AspMvcActionAttribute(string anonymousProperty)
+		{
+			AnonymousProperty = anonymousProperty;
+		}
+
+		public string AnonymousProperty { get; private set; }
+	}
+
+	/// <summary>
+	/// ASP.NET MVC attribute. Indicates that a parameter is an MVC area.
+	/// Use this attribute for custom wrappers similar to
+	/// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcAreaAttribute : PathReferenceAttribute
+	{
+		public AspMvcAreaAttribute() { }
+		public AspMvcAreaAttribute(string anonymousProperty)
+		{
+			AnonymousProperty = anonymousProperty;
+		}
+
+		public string AnonymousProperty { get; private set; }
+	}
+
+	/// <summary>
+	/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is
+	/// an MVC controller. If applied to a method, the MVC controller name is calculated
+	/// implicitly from the context. Use this attribute for custom wrappers similar to
+	/// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcControllerAttribute : Attribute
+	{
+		public AspMvcControllerAttribute() { }
+		public AspMvcControllerAttribute(string anonymousProperty)
+		{
+			AnonymousProperty = anonymousProperty;
+		}
+
+		public string AnonymousProperty { get; private set; }
+	}
+
+	/// <summary>
+	/// ASP.NET MVC attribute. Indicates that a parameter is an MVC Master. Use this attribute
+	/// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcMasterAttribute : Attribute { }
+
+	/// <summary>
+	/// ASP.NET MVC attribute. Indicates that a parameter is an MVC model type. Use this attribute
+	/// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, Object)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcModelTypeAttribute : Attribute { }
+
+	/// <summary>
+	/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC
+	/// partial view. If applied to a method, the MVC partial view name is calculated implicitly
+	/// from the context. Use this attribute for custom wrappers similar to
+	/// <c>System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcPartialViewAttribute : PathReferenceAttribute { }
+
+	/// <summary>
+	/// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcSupressViewErrorAttribute : Attribute { }
+
+	/// <summary>
+	/// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
+	/// Use this attribute for custom wrappers similar to 
+	/// <c>System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcDisplayTemplateAttribute : Attribute { }
+
+	/// <summary>
+	/// ASP.NET MVC attribute. Indicates that a parameter is an MVC editor template.
+	/// Use this attribute for custom wrappers similar to
+	/// <c>System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcEditorTemplateAttribute : Attribute { }
+
+	/// <summary>
+	/// ASP.NET MVC attribute. Indicates that a parameter is an MVC template.
+	/// Use this attribute for custom wrappers similar to
+	/// <c>System.ComponentModel.DataAnnotations.UIHintAttribute(System.String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcTemplateAttribute : Attribute { }
+
+	/// <summary>
+	/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+	/// is an MVC view. If applied to a method, the MVC view name is calculated implicitly
+	/// from the context. Use this attribute for custom wrappers similar to
+	/// <c>System.Web.Mvc.Controller.View(Object)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcViewAttribute : PathReferenceAttribute { }
+
+	/// <summary>
+	/// ASP.NET MVC attribute. When applied to a parameter of an attribute,
+	/// indicates that this parameter is an MVC action name
+	/// </summary>
+	/// <example><code>
+	/// [ActionName("Foo")]
+	/// public ActionResult Login(string returnUrl) {
+	///   ViewBag.ReturnUrl = Url.Action("Foo"); // OK
+	///   return RedirectToAction("Bar"); // Error: Cannot resolve action
+	/// }
+	/// </code></example>
+	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMvcActionSelectorAttribute : Attribute { }
+
+	[AttributeUsage(
+	  AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class HtmlElementAttributesAttribute : Attribute
+	{
+		public HtmlElementAttributesAttribute() { }
+		public HtmlElementAttributesAttribute(string name)
+		{
+			Name = name;
+		}
+
+		public string Name { get; private set; }
+	}
+
+	[AttributeUsage(
+	  AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class HtmlAttributeValueAttribute : Attribute
+	{
+		public HtmlAttributeValueAttribute([NotNull] string name)
+		{
+			Name = name;
+		}
+
+		[NotNull]
+		public string Name { get; private set; }
+	}
+
+	/// <summary>
+	/// Razor attribute. Indicates that a parameter or a method is a Razor section.
+	/// Use this attribute for custom wrappers similar to 
+	/// <c>System.Web.WebPages.WebPageBase.RenderSection(String)</c>
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RazorSectionAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates how method invocation affects content of the collection
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class CollectionAccessAttribute : Attribute
+	{
+		public CollectionAccessAttribute(CollectionAccessType collectionAccessType)
+		{
+			CollectionAccessType = collectionAccessType;
+		}
+
+		public CollectionAccessType CollectionAccessType { get; private set; }
+	}
+
+	[Flags]
+	public enum CollectionAccessType
+	{
+		/// <summary>Method does not use or modify content of the collection</summary>
+		None = 0,
+		/// <summary>Method only reads content of the collection but does not modify it</summary>
+		Read = 1,
+		/// <summary>Method can change content of the collection but does not add new elements</summary>
+		ModifyExistingContent = 2,
+		/// <summary>Method can add new elements to the collection</summary>
+		UpdatedContent = ModifyExistingContent | 4
+	}
+
+	/// <summary>
+	/// Indicates that the marked method is assertion method, i.e. it halts control flow if
+	/// one of the conditions is satisfied. To set the condition, mark one of the parameters with 
+	/// <see cref="AssertionConditionAttribute"/> attribute
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AssertionMethodAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates the condition parameter of the assertion method. The method itself should be
+	/// marked by <see cref="AssertionMethodAttribute"/> attribute. The mandatory argument of
+	/// the attribute is the assertion type.
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AssertionConditionAttribute : Attribute
+	{
+		public AssertionConditionAttribute(AssertionConditionType conditionType)
+		{
+			ConditionType = conditionType;
+		}
+
+		public AssertionConditionType ConditionType { get; private set; }
+	}
+
+	/// <summary>
+	/// Specifies assertion type. If the assertion method argument satisfies the condition,
+	/// then the execution continues. Otherwise, execution is assumed to be halted
+	/// </summary>
+	public enum AssertionConditionType
+	{
+		/// <summary>Marked parameter should be evaluated to true</summary>
+		IS_TRUE = 0,
+		/// <summary>Marked parameter should be evaluated to false</summary>
+		IS_FALSE = 1,
+		/// <summary>Marked parameter should be evaluated to null value</summary>
+		IS_NULL = 2,
+		/// <summary>Marked parameter should be evaluated to not null value</summary>
+		IS_NOT_NULL = 3,
+	}
+
+	/// <summary>
+	/// Indicates that the marked method unconditionally terminates control flow execution.
+	/// For example, it could unconditionally throw exception
+	/// </summary>
+	[Obsolete("Use [ContractAnnotation('=> halt')] instead")]
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class TerminatesProgramAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select,
+	/// .Where). This annotation allows inference of [InstantHandle] annotation for parameters
+	/// of delegate type by analyzing LINQ method chains.
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class LinqTunnelAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that IEnumerable, passed as parameter, is not enumerated.
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class NoEnumerationAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that parameter is regular expression pattern.
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RegexPatternAttribute : Attribute { }
+
+	/// <summary>
+	/// XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be
+	/// treated as <c>ItemsControl</c>-derived type, to enable inner  items <c>DataContext</c>
+	/// type resolve.
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Class)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class XamlItemsControlAttribute : Attribute { }
+
+	/// <summary>
+	/// XAML attibute. Indicates the property of some <c>BindingBase</c>-derived type, that
+	/// is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
+	/// enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
+	/// </summary>
+	/// <remarks>
+	/// Property should have the tree ancestor of the <c>ItemsControl</c> type or
+	/// marked with the <see cref="XamlItemsControlAttribute"/> attribute.
+	/// </remarks>
+	[AttributeUsage(AttributeTargets.Property)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class XamlItemBindingOfItemsControlAttribute : Attribute { }
+
+	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspChildControlTypeAttribute : Attribute
+	{
+		public AspChildControlTypeAttribute(string tagName, Type controlType)
+		{
+			TagName = tagName;
+			ControlType = controlType;
+		}
+
+		public string TagName { get; private set; }
+		public Type ControlType { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspDataFieldAttribute : Attribute { }
+
+	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspDataFieldsAttribute : Attribute { }
+
+	[AttributeUsage(AttributeTargets.Property)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspMethodPropertyAttribute : Attribute { }
+
+	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspRequiredAttributeAttribute : Attribute
+	{
+		public AspRequiredAttributeAttribute([NotNull] string attribute)
+		{
+			Attribute = attribute;
+		}
+
+		public string Attribute { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Property)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class AspTypePropertyAttribute : Attribute
+	{
+		public bool CreateConstructorReferences { get; private set; }
+
+		public AspTypePropertyAttribute(bool createConstructorReferences)
+		{
+			CreateConstructorReferences = createConstructorReferences;
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RazorImportNamespaceAttribute : Attribute
+	{
+		public RazorImportNamespaceAttribute(string name)
+		{
+			Name = name;
+		}
+
+		public string Name { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RazorInjectionAttribute : Attribute
+	{
+		public RazorInjectionAttribute(string type, string fieldName)
+		{
+			Type = type;
+			FieldName = fieldName;
+		}
+
+		public string Type { get; private set; }
+		public string FieldName { get; private set; }
+	}
+
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RazorHelperCommonAttribute : Attribute { }
+
+	[AttributeUsage(AttributeTargets.Property)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RazorLayoutAttribute : Attribute { }
+
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RazorWriteLiteralMethodAttribute : Attribute { }
+
+	[AttributeUsage(AttributeTargets.Method)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RazorWriteMethodAttribute : Attribute { }
+
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class RazorWriteMethodParameterAttribute : Attribute { }
+
+	/// <summary>
+	/// Prevents the Member Reordering feature from tossing members of the marked class.
+	/// </summary>
+	/// <remarks>
+	/// The attribute must be mentioned in your member reordering patterns.
+	/// </remarks>
+	[AttributeUsage(AttributeTargets.All)]
+	[Conditional("JETBRAINS_ANNOTATIONS")]
+	public sealed class NoReorder : Attribute { }
+}
+
+#endif

JNFrame2/Assets/Plugins/SRF/External/Jetbrains.Annotations.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 643a949c9c71dd94a970b2573c29fe67
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

JNFrame2/Assets/Plugins/SRF/External/MiniJSON.cs

@@ -0,0 +1,626 @@
+/*
+ * Copyright (c) 2013 Calvin Rien
+ *
+ * Based on the JSON parser by Patrick van Bergen
+ * http://techblog.procurios.nl/k/618/news/view/14605/14863/How-do-I-write-my-own-parser-for-JSON.html
+ *
+ * Simplified it so that it doesn't throw exceptions
+ * and can be used in Unity iPhone with maximum code stripping.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+using System.Globalization;
+
+namespace SRF
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Text;
+
+    // Example usage:
+    //
+    //  using UnityEngine;
+    //  using System.Collections;
+    //  using System.Collections.Generic;
+    //  using MiniJSON;
+    //
+    //  public class MiniJSONTest : MonoBehaviour {
+    //      void Start () {
+    //          var jsonString = "{ \"array\": [1.44,2,3], " +
+    //                          "\"object\": {\"key1\":\"value1\", \"key2\":256}, " +
+    //                          "\"string\": \"The quick brown fox \\\"jumps\\\" over the lazy dog \", " +
+    //                          "\"unicode\": \"\\u3041 Men\u00fa sesi\u00f3n\", " +
+    //                          "\"int\": 65536, " +
+    //                          "\"float\": 3.1415926, " +
+    //                          "\"bool\": true, " +
+    //                          "\"null\": null }";
+    //
+    //          var dict = Json.Deserialize(jsonString) as Dictionary<string,object>;
+    //
+    //          Debug.Log("deserialized: " + dict.GetType());
+    //          Debug.Log("dict['array'][0]: " + ((List<object>) dict["array"])[0]);
+    //          Debug.Log("dict['string']: " + (string) dict["string"]);
+    //          Debug.Log("dict['float']: " + (double) dict["float"]); // floats come out as doubles
+    //          Debug.Log("dict['int']: " + (long) dict["int"]); // ints come out as longs
+    //          Debug.Log("dict['unicode']: " + (string) dict["unicode"]);
+    //
+    //          var str = Json.Serialize(dict);
+    //
+    //          Debug.Log("serialized: " + str);
+    //      }
+    //  }
+
+    /// <summary>
+    /// This class encodes and decodes JSON strings.
+    /// Spec. details, see http://www.json.org/
+    /// JSON uses Arrays and Objects. These correspond here to the datatypes IList and IDictionary.
+    /// All numbers are parsed to doubles.
+    /// </summary>
+    public static class Json
+    {
+        /// <summary>
+        /// Parses the string json into a value
+        /// </summary>
+        /// <param name="json">A JSON string.</param>
+        /// <returns>An List&lt;object&gt;, a Dictionary&lt;string, object&gt;, a double, an integer,a string, null, true, or false</returns>
+        public static object Deserialize(string json)
+        {
+            // save the string for debug information
+            if (json == null)
+            {
+                return null;
+            }
+
+            return Parser.Parse(json);
+        }
+
+        /// <summary>
+        /// Converts a IDictionary / IList object or a simple type (string, int, etc.) into a JSON string
+        /// </summary>
+        /// <param name="json">A Dictionary&lt;string, object&gt; / List&lt;object&gt;</param>
+        /// <returns>A JSON encoded string, or null if object 'json' is not serializable</returns>
+        public static string Serialize(object obj)
+        {
+            return Serializer.Serialize(obj);
+        }
+
+        private sealed class Parser : IDisposable
+        {
+            private const string WORD_BREAK = "{}[],:\"";
+            private StringReader json;
+
+            private Parser(string jsonString)
+            {
+                json = new StringReader(jsonString);
+            }
+
+            private char PeekChar
+            {
+                get { return Convert.ToChar(json.Peek()); }
+            }
+
+            private char NextChar
+            {
+                get { return Convert.ToChar(json.Read()); }
+            }
+
+            private string NextWord
+            {
+                get
+                {
+                    var word = new StringBuilder();
+
+                    while (!IsWordBreak(PeekChar))
+                    {
+                        word.Append(NextChar);
+
+                        if (json.Peek() == -1)
+                        {
+                            break;
+                        }
+                    }
+
+                    return word.ToString();
+                }
+            }
+
+            private TOKEN NextToken
+            {
+                get
+                {
+                    EatWhitespace();
+
+                    if (json.Peek() == -1)
+                    {
+                        return TOKEN.NONE;
+                    }
+
+                    switch (PeekChar)
+                    {
+                        case '{':
+                            return TOKEN.CURLY_OPEN;
+                        case '}':
+                            json.Read();
+                            return TOKEN.CURLY_CLOSE;
+                        case '[':
+                            return TOKEN.SQUARED_OPEN;
+                        case ']':
+                            json.Read();
+                            return TOKEN.SQUARED_CLOSE;
+                        case ',':
+                            json.Read();
+                            return TOKEN.COMMA;
+                        case '"':
+                            return TOKEN.STRING;
+                        case ':':
+                            return TOKEN.COLON;
+                        case '0':
+                        case '1':
+                        case '2':
+                        case '3':
+                        case '4':
+                        case '5':
+                        case '6':
+                        case '7':
+                        case '8':
+                        case '9':
+                        case '-':
+                            return TOKEN.NUMBER;
+                    }
+
+                    switch (NextWord)
+                    {
+                        case "false":
+                            return TOKEN.FALSE;
+                        case "true":
+                            return TOKEN.TRUE;
+                        case "null":
+                            return TOKEN.NULL;
+                    }
+
+                    return TOKEN.NONE;
+                }
+            }
+
+            public void Dispose()
+            {
+                json.Dispose();
+                json = null;
+            }
+
+            public static bool IsWordBreak(char c)
+            {
+                return char.IsWhiteSpace(c) || WORD_BREAK.IndexOf(c) != -1;
+            }
+
+            public static object Parse(string jsonString)
+            {
+                using (var instance = new Parser(jsonString))
+                {
+                    return instance.ParseValue();
+                }
+            }
+
+            private Dictionary<string, object> ParseObject()
+            {
+                var table = new Dictionary<string, object>();
+
+                // ditch opening brace
+                json.Read();
+
+                // {
+                while (true)
+                {
+                    switch (NextToken)
+                    {
+                        case TOKEN.NONE:
+                            return null;
+                        case TOKEN.COMMA:
+                            continue;
+                        case TOKEN.CURLY_CLOSE:
+                            return table;
+                        default:
+                            // name
+                            var name = ParseString();
+                            if (name == null)
+                            {
+                                return null;
+                            }
+
+                            // :
+                            if (NextToken != TOKEN.COLON)
+                            {
+                                return null;
+                            }
+                            // ditch the colon
+                            json.Read();
+
+                            // value
+                            table[name] = ParseValue();
+                            break;
+                    }
+                }
+            }
+
+            private List<object> ParseArray()
+            {
+                var array = new List<object>();
+
+                // ditch opening bracket
+                json.Read();
+
+                // [
+                var parsing = true;
+                while (parsing)
+                {
+                    var nextToken = NextToken;
+
+                    switch (nextToken)
+                    {
+                        case TOKEN.NONE:
+                            return null;
+                        case TOKEN.COMMA:
+                            continue;
+                        case TOKEN.SQUARED_CLOSE:
+                            parsing = false;
+                            break;
+                        default:
+                            var value = ParseByToken(nextToken);
+
+                            array.Add(value);
+                            break;
+                    }
+                }
+
+                return array;
+            }
+
+            private object ParseValue()
+            {
+                var nextToken = NextToken;
+                return ParseByToken(nextToken);
+            }
+
+            private object ParseByToken(TOKEN token)
+            {
+                switch (token)
+                {
+                    case TOKEN.STRING:
+                        return ParseString();
+                    case TOKEN.NUMBER:
+                        return ParseNumber();
+                    case TOKEN.CURLY_OPEN:
+                        return ParseObject();
+                    case TOKEN.SQUARED_OPEN:
+                        return ParseArray();
+                    case TOKEN.TRUE:
+                        return true;
+                    case TOKEN.FALSE:
+                        return false;
+                    case TOKEN.NULL:
+                        return null;
+                    default:
+                        return null;
+                }
+            }
+
+            private string ParseString()
+            {
+                var s = new StringBuilder();
+                char c;
+
+                // ditch opening quote
+                json.Read();
+
+                var parsing = true;
+                while (parsing)
+                {
+                    if (json.Peek() == -1)
+                    {
+                        parsing = false;
+                        break;
+                    }
+
+                    c = NextChar;
+                    switch (c)
+                    {
+                        case '"':
+                            parsing = false;
+                            break;
+                        case '\\':
+                            if (json.Peek() == -1)
+                            {
+                                parsing = false;
+                                break;
+                            }
+
+                            c = NextChar;
+                            switch (c)
+                            {
+                                case '"':
+                                case '\\':
+                                case '/':
+                                    s.Append(c);
+                                    break;
+                                case 'b':
+                                    s.Append('\b');
+                                    break;
+                                case 'f':
+                                    s.Append('\f');
+                                    break;
+                                case 'n':
+                                    s.Append('\n');
+                                    break;
+                                case 'r':
+                                    s.Append('\r');
+                                    break;
+                                case 't':
+                                    s.Append('\t');
+                                    break;
+                                case 'u':
+                                    var hex = new char[4];
+
+                                    for (var i = 0; i < 4; i++)
+                                    {
+                                        hex[i] = NextChar;
+                                    }
+
+                                    s.Append((char) Convert.ToInt32(new string(hex), 16));
+                                    break;
+                            }
+                            break;
+                        default:
+                            s.Append(c);
+                            break;
+                    }
+                }
+
+                return s.ToString();
+            }
+
+            private object ParseNumber()
+            {
+                var number = NextWord;
+
+                if (number.IndexOf('.') == -1)
+                {
+                    long parsedInt;
+                    long.TryParse(number, out parsedInt);
+                    return parsedInt;
+                }
+
+                double parsedDouble;
+                double.TryParse(number, out parsedDouble);
+                return parsedDouble;
+            }
+
+            private void EatWhitespace()
+            {
+                while (char.IsWhiteSpace(PeekChar))
+                {
+                    json.Read();
+
+                    if (json.Peek() == -1)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            private enum TOKEN
+            {
+                NONE,
+                CURLY_OPEN,
+                CURLY_CLOSE,
+                SQUARED_OPEN,
+                SQUARED_CLOSE,
+                COLON,
+                COMMA,
+                STRING,
+                NUMBER,
+                TRUE,
+                FALSE,
+                NULL
+            };
+        }
+
+        private sealed class Serializer
+        {
+            private StringBuilder builder;
+
+            private Serializer()
+            {
+                builder = new StringBuilder();
+            }
+
+            public static string Serialize(object obj)
+            {
+                var instance = new Serializer();
+
+                instance.SerializeValue(obj);
+
+                return instance.builder.ToString();
+            }
+
+            private void SerializeValue(object value)
+            {
+                IList asList;
+                IDictionary asDict;
+                string asStr;
+
+                if (value == null)
+                {
+                    builder.Append("null");
+                }
+                else if ((asStr = value as string) != null)
+                {
+                    SerializeString(asStr);
+                }
+                else if (value is bool)
+                {
+                    builder.Append((bool) value ? "true" : "false");
+                }
+                else if ((asList = value as IList) != null)
+                {
+                    SerializeArray(asList);
+                }
+                else if ((asDict = value as IDictionary) != null)
+                {
+                    SerializeObject(asDict);
+                }
+                else if (value is char)
+                {
+                    SerializeString(new string((char) value, 1));
+                }
+                else
+                {
+                    SerializeOther(value);
+                }
+            }
+
+            private void SerializeObject(IDictionary obj)
+            {
+                var first = true;
+
+                builder.Append('{');
+
+                foreach (var e in obj.Keys)
+                {
+                    if (!first)
+                    {
+                        builder.Append(',');
+                    }
+
+                    SerializeString(e.ToString());
+                    builder.Append(':');
+
+                    SerializeValue(obj[e]);
+
+                    first = false;
+                }
+
+                builder.Append('}');
+            }
+
+            private void SerializeArray(IList anArray)
+            {
+                builder.Append('[');
+
+                var first = true;
+
+                foreach (var obj in anArray)
+                {
+                    if (!first)
+                    {
+                        builder.Append(',');
+                    }
+
+                    SerializeValue(obj);
+
+                    first = false;
+                }
+
+                builder.Append(']');
+            }
+
+            private void SerializeString(string str)
+            {
+                builder.Append('\"');
+
+                var charArray = str.ToCharArray();
+                foreach (var c in charArray)
+                {
+                    switch (c)
+                    {
+                        case '"':
+                            builder.Append("\\\"");
+                            break;
+                        case '\\':
+                            builder.Append("\\\\");
+                            break;
+                        case '\b':
+                            builder.Append("\\b");
+                            break;
+                        case '\f':
+                            builder.Append("\\f");
+                            break;
+                        case '\n':
+                            builder.Append("\\n");
+                            break;
+                        case '\r':
+                            builder.Append("\\r");
+                            break;
+                        case '\t':
+                            builder.Append("\\t");
+                            break;
+                        default:
+                            var codepoint = Convert.ToInt32(c);
+                            if ((codepoint >= 32) && (codepoint <= 126))
+                            {
+                                builder.Append(c);
+                            }
+                            else
+                            {
+                                builder.Append("\\u");
+                                builder.Append(codepoint.ToString("x4"));
+                            }
+                            break;
+                    }
+                }
+
+                builder.Append('\"');
+            }
+
+            private void SerializeOther(object value)
+            {
+                // NOTE: decimals lose precision during serialization.
+                // They always have, I'm just letting you know.
+                // Previously floats and doubles lost precision too.
+                if (value is float)
+                {
+                    builder.Append(((float) value).ToString("R", CultureInfo.InvariantCulture));
+                }
+                else if (value is int
+                         || value is uint
+                         || value is long
+                         || value is sbyte
+                         || value is byte
+                         || value is short
+                         || value is ushort
+                         || value is ulong)
+                {
+                    builder.Append(value);
+                }
+                else if (value is double
+                         || value is decimal)
+                {
+                    builder.Append(Convert.ToDouble(value).ToString("R", CultureInfo.InvariantCulture));
+                }
+                else
+                {
+                    SerializeString(value.ToString());
+                }
+            }
+        }
+    }
+}

JNFrame2/Assets/Plugins/SRF/External/MiniJSON.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ac9ef7034b8966443b1c264ec9cf4cdd
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: