private void ComputeOffsetsAndIndexes()

in src/Proton/Buffer/ProtonCompositeBuffer.cs [980:1051]
63 lines of code
14 McCabe index (conditional complexity)

      private void ComputeOffsetsAndIndexes()
      {
         long writeOffset = 0;
         long readOffset = 0;

         // Compute read offset and write offsets into the provided buffers and check
         // invariants such as no read or write gaps etc.
         if (buffers.Length > 0)
         {
            bool unwrittenBufferEnforced = false;
            bool unreadBufferEnforced = false;

            foreach (IProtonBuffer buffer in buffers)
            {
               if (!unwrittenBufferEnforced)
               {
                  writeOffset += buffer.WriteOffset;
                  if (buffer.WritableBytes > 0)
                  {
                     unwrittenBufferEnforced = true;
                  }
               }
               else if (buffer.WriteOffset != 0)
               {
                  throw new ArgumentOutOfRangeException(
                     "Cannot compose the given buffers due to gap in writeable portion of span");
               }
            }
            foreach (IProtonBuffer buffer in buffers)
            {
               if (!unreadBufferEnforced)
               {
                  readOffset += buffer.ReadOffset;
                  if (buffer.ReadableBytes > 0 || buffer.WritableBytes > 0)
                  {
                     unreadBufferEnforced = true;
                  }
               }
               else if (buffer.ReadOffset != 0)
               {
                  throw new ArgumentOutOfRangeException(
                     "Cannot compose the given buffers due to gap in readable portion of span");
               }
            }

            if (readOffset > writeOffset)
            {
               throw new ArgumentOutOfRangeException(
                  "Composed buffers resulted in read offset ahead of write offset");
            }
         }

         this.readOffset = readOffset;
         this.writeOffset = writeOffset;
         this.indexTracker = new long[buffers.Length];

         long capacity = 0;
         for (int i = 0; i < buffers.Length; ++i)
         {
            indexTracker[i] = capacity;
            capacity += buffers[i].Capacity;
         }

         if (capacity > MAX_CAPACITY)
         {
            throw new ArgumentOutOfRangeException(string.Format(
               "Cannot create a buffer with combined capacity greater than {0} " +
               "due to array copy constraints. Input buffers capacity was : {1}", MAX_CAPACITY, capacity));
         }

         this.capacity = capacity;
      }