Class ExifReader has 29 methods (exceeds 20 allowed). Consider refactoring.

Open

    public sealed class ExifReader : IDisposable
    {
        private readonly Stream _stream;
        private readonly BinaryReader _reader;
        /// <summary>

Class ImmutableExtensions has 29 methods (exceeds 20 allowed). Consider refactoring.

Open

    public static class ImmutableExtensions {

        private class Wrapper { // To wrap listener actions
            public Action stateChangeListener;
        }

Similar blocks of code found in 3 locations. Consider refactoring.

Open

        public static BsonValue operator -(BsonValue left, BsonValue right)
        {
            if (!left.IsNumber || !right.IsNumber) return BsonValue.Null;

            if (left.IsInt32 && right.IsInt32) return left.AsInt32 - right.AsInt32;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

        public static BsonValue operator +(BsonValue left, BsonValue right)
        {
            if (!left.IsNumber || !right.IsNumber) return BsonValue.Null;

            if (left.IsInt32 && right.IsInt32) return left.AsInt32 + right.AsInt32;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

        public static BsonValue operator *(BsonValue left, BsonValue right)
        {
            if (!left.IsNumber || !right.IsNumber) return BsonValue.Null;

            if (left.IsInt32 && right.IsInt32) return left.AsInt32 * right.AsInt32;

• Read up
  Read up

Method Unpatch has 86 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        public JToken Unpatch(JToken right, JToken patch)
        {
            if (patch == null)
                return right;

Method WriteElement has 86 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        private static void WriteElement(ByteWriter writer, string key, BsonValue value)
        {
            // cast RawValue to avoid one if on As<Type>
            switch (value.Type)
            {

Method stbi__process_gif_raster has a Cognitive Complexity of 39 (exceeds 20 allowed). Consider refactoring.

Open

        private byte[] stbi__process_gif_raster()
        {
            byte lzw_cs = 0;
            var len = 0;
            var init_code = 0;

• Read up
  Read up

Method diff_cleanupSemantic has 85 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public void diff_cleanupSemantic(List<Diff> diffs) {
      bool changes = false;
      // Stack of indices where equalities are found.
      Stack<int> equalities = new Stack<int>();
      // Always equal to equalities[equalitiesLength-1][1]

Method patch_splitMax has 85 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public void patch_splitMax(List<Patch> patches) {
      short patch_size = this.Match_MaxBits;
      for (int x = 0; x < patches.Count; x++) {
        if (patches[x].length1 <= patch_size) {
          continue;

File TgaDecoder.cs has 307 lines of code (exceeds 250 allowed). Consider refactoring.

Open

using System.IO;
using StbImageSharp.Utility;

namespace StbImageSharp.Decoding
{

Class BsonDocument has 28 methods (exceeds 20 allowed). Consider refactoring.

Open

    public class BsonDocument : BsonValue, IDictionary<string, BsonValue>
    {
        public BsonDocument()
            : base(BsonType.Document, new Dictionary<string, BsonValue>(StringComparer.OrdinalIgnoreCase))
        {

Class FileExtensions has 28 methods (exceeds 20 allowed). Consider refactoring.

Open

    public static class FileExtensions {

        public static DirectoryInfo GetChildDir(this DirectoryInfo self, string subDirName, bool assertThatChildMustExist = false, bool sanitize = true) {
            subDirName.ThrowErrorIfNullOrEmpty("subDirName");
            if (sanitize) { subDirName = Sanitize.SanitizeToDirName(subDirName); }

Class ZipFileReadSystem has 28 methods (exceeds 20 allowed). Consider refactoring.

Open

    [Obsolete("Use ZipArchiveFileSystem instead")] 
    public class ZipFileReadSystem : FileSystem {

        private readonly ZipFile zip;

Consider simplifying this complex logical expression.

Open

                if ((v >= 'a' && v <= 'z') || (v >= 'A' && v <= 'Z') || (v >= '0' && v <= '9') ||
                    v == '+' || v == '/' || v == ':' || v == '.' || v == '-' || v == '_' || v == '~' ||
                    v > '\xFF') {
                    uri.Append(v);
                } else if (v == Path.DirectorySeparatorChar || v == Path.AltDirectorySeparatorChar) {

Class AssertV3 has 28 methods (exceeds 20 allowed). Consider refactoring.

Open

    public static class AssertV3 {

        private const string LB = "\r\n";
        private static object syncLock = new object();

Class AssertV2 has 28 methods (exceeds 20 allowed). Consider refactoring.

Open

    [Obsolete("Use AssertV3 instead")]
    public static class AssertV2 {

        private const string LB = "\r\n";
        private static object syncLock = new object();

Method Deserialize has 82 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        internal object Deserialize(Type type, BsonValue value)
        {
            Func<BsonValue, object> custom;

            // null value - null returns

Method match_bitap has a Cognitive Complexity of 38 (exceeds 20 allowed). Consider refactoring.

Open

    protected int match_bitap(string text, string pattern, int loc) {
      // assert (Match_MaxBits == 0 || pattern.Length <= Match_MaxBits)
      //    : "Pattern too long for this application.";

      // Initialise the alphabet.

• Read up
  Read up

File MeshChainRenderer.cs has 302 lines of code (exceeds 250 allowed). Consider refactoring.

Open

using System;
using UnityEngine;

namespace com.csutil.rendering
{