public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     data = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(data).Length;
     return (curIndex - startIndex);
 }

        /// <summary>Initializes a new instance of the Abstract1 class.</summary>
        protected Abstract1(
			System.UInt32 identity,
			System.Int32 abstract1Field1,
			System.Int32 abstract1Field2,
			ImmutableObjectGraph.Optional<bool> skipValidation = default(ImmutableObjectGraph.Optional<bool>))
        {
            this.identity = identity;
            this.abstract1Field1 = abstract1Field1;
            this.abstract1Field2 = abstract1Field2;
        }

        /// <summary>Initializes a new instance of the A class.</summary>
        protected A(
			System.UInt32 identity,
			System.Int32 field1,
			ImmutableObjectGraph.Optional<bool> skipValidation = default(ImmutableObjectGraph.Optional<bool>))
        {
            this.identity = identity;
            this.field1 = field1;
            if (!skipValidation.Value) {
                this.Validate();
            }
        }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     seq = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(seq).Length;
     curIndex += stamp.Deserialize(serialized, curIndex);
     System.UInt32 frame_id_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(frame_id_len).Length;
     frame_id = System.Text.Encoding.UTF8.GetString(serialized, curIndex, (int)frame_id_len);
     curIndex += (int)frame_id_len;
     return (curIndex - startIndex);
 }

        /// <summary>Initializes a new instance of the ReqAndHierL1 class.</summary>
        protected ReqAndHierL1(
			System.UInt32 identity,
			System.String l1Field1,
			System.String l1Field2,
			ImmutableObjectGraph.Optional<bool> skipValidation = default(ImmutableObjectGraph.Optional<bool>))
        {
            this.identity = identity;
            this.l1Field1 = l1Field1;
            this.l1Field2 = l1Field2;
            if (!skipValidation.Value) {
                this.Validate();
            }
        }

        /// <summary>Initializes a new instance of the Contact class.</summary>
        protected Contact(
			System.UInt32 identity,
			System.String name,
			System.String email,
			ImmutableObjectGraph.Optional<bool> skipValidation = default(ImmutableObjectGraph.Optional<bool>))
        {
            this.identity = identity;
            this.name = name;
            this.email = email;
            if (!skipValidation.Value) {
                this.Validate();
            }
        }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     System.UInt32 label_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(label_len).Length;
     label = System.Text.Encoding.UTF8.GetString(serialized, curIndex, (int)label_len);
     curIndex += (int)label_len;
     size = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(size).Length;
     stride = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(stride).Length;
     return (curIndex - startIndex);
 }

        /// <summary>Initializes a new instance of the Fruit class.</summary>
        protected Fruit(
			System.UInt32 identity,
			System.String color,
			System.Int32 skinThickness,
			ImmutableObjectGraph.Optional<bool> skipValidation = default(ImmutableObjectGraph.Optional<bool>))
        {
            this.identity = identity;
            this.color = color;
            this.skinThickness = skinThickness;
            if (!skipValidation.Value) {
                this.Validate();
            }
        }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     x_offset = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(x_offset).Length;
     y_offset = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(y_offset).Length;
     height = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(height).Length;
     width = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(width).Length;
     do_rectify = Convert.ToBoolean(serialized[curIndex]);
     curIndex++;
     return (curIndex - startIndex);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     System.UInt32 dim_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(dim_len).Length;
     for (int i = 0; i < (int)dim_len; i++)
     {
         std_msgs.MultiArrayDimension element = new std_msgs.MultiArrayDimension();
         curIndex += element.Deserialize(serialized, curIndex);
         dim.Add(element);
     }
     data_offset = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(data_offset).Length;
     return (curIndex - startIndex);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     System.UInt32 name_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(name_len).Length;
     name = System.Text.Encoding.UTF8.GetString(serialized, curIndex, (int)name_len);
     curIndex += (int)name_len;
     offset = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(offset).Length;
     datatype = serialized[curIndex];
     curIndex++;
     count = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(count).Length;
     return (curIndex - startIndex);
 }

 public PointField()
 {
     name = "";
     offset = 0;
     datatype = 0;
     count = 0;
 }

        public PgHdr pPgHdr = new PgHdr();  // Pointer to Actual Page Header

        public void Clear()
        {
            this.iKey = 0;
            this.pNext = null;
            this.pCache = null;
            this.pPgHdr.ClearState();
        }

      public u32 iMaxKey;               /* Largest key seen since xTruncate() */


      public void Clear()
      {
        nRecyclable = 0;
        nPage = 0;
        nHash = 0;
        apHash = null;
        iMaxKey = 0;
      }

 public void Subtract()
 {
     unchecked
     {
         var complement = (DoubleWord)(-InputB);
         Output = (DoubleWord)InputA - InputB;
     }
 }

 public RegionOfInterest()
 {
     x_offset = 0;
     y_offset = 0;
     height = 0;
     width = 0;
     do_rectify = false;
 }

 public TrackerState()
 {
     header = new std_msgs.Header();
     ActiveTracks = 0;
     TotalTracks = 0;
     Tracks = new List<person_tracker.TrackedPerson>();
     TrackerType = 0;
     TrackerName = "";
 }

 public Image()
 {
     header = new std_msgs.Header();
     height = 0;
     width = 0;
     encoding = "";
     is_bigendian = 0;
     step = 0;
     data = new List<System.Byte>();
 }

 internal RC btreeSetHasContent(Pgno pgno)
 {
     var rc = RC.OK;
     if (this.HasContent == null)
     {
         Debug.Assert(pgno <= this.Pages);
         this.HasContent = new BitArray(this.Pages);
     }
     if (rc == RC.OK && pgno <= this.HasContent.Length)
         rc = this.HasContent.Set(pgno);
     return rc;
 }

 public PointCloud2()
 {
     header = new std_msgs.Header();
     height = 0;
     width = 0;
     fields = new List<sensor_msgs.PointField>();
     is_bigendian = false;
     point_step = 0;
     row_step = 0;
     data = new List<System.Byte>();
     is_dense = false;
 }