Esempio n. 1
0
    public static void Main()
    {
        Eina.Config.Init();

        var bytes = new byte[] { 0, 1, 2, 3, 4, 5, 6 };

        var bb = new Eina.Binbuf();

        // Append initial bytes
        bb.Append(bytes);

        WriteLine("Printing each byte.");

        int idx = 0;

        foreach (byte b in bb.GetBytes())
        {
            WriteLine($"byte at[{idx}]: {b}");
            ++idx;
        }

        // Append more byte by byte
        bb.Append((byte)7);
        bb.Append((byte)8);
        bb.Append((byte)9);
        bb.Append((byte)0);

        WriteLine("\nPrinting each byte.");

        idx = 0;
        foreach (byte b in bb.GetBytes())
        {
            WriteLine($"byte at[{idx}]: {b}");
            ++idx;
        }

        // Remove some
        bb.Remove(2, 5);

        WriteLine("\nPrinting each byte.");

        idx = 0;
        foreach (byte b in bb.GetBytes())
        {
            WriteLine($"byte at[{idx}]: {b}");
            ++idx;
        }

        // Insert new bytes in the middle
        bb.Insert(new byte[] { 22, 33, 44 }, 2);

        WriteLine("\nPrinting each byte.");

        idx = 0;
        foreach (byte b in bb.GetBytes())
        {
            WriteLine($"byte at[{idx}]: {b}");
            ++idx;
        }
    }
Esempio n. 2
0
        public bool binbuf_return_own_no_longer_own()
        {
            bool r = !binbuf_return_own_binbuf.Own;

            binbuf_return_own_binbuf.Dispose();
            binbuf_return_own_binbuf = null;
            return(r);
        }
Esempio n. 3
0
        /// <summary>
        ///   Create a new buffer with elements.
        /// </summary>
        /// <para>Since EFL 1.23.</para>
        /// <param name="bb">Elements to initialize the new buffer.</param>
        public Binbuf(Binbuf bb)
        {
            InitNew();

            if (bb != null)
            {
                Append(bb);
            }
        }
Esempio n. 4
0
        internal static Dummy.StructComplex structComplexWithValues()
        {
            var Farray = new Eina.Array <string>();

            Farray.Add("0x0");
            Farray.Add("0x2A");
            Farray.Add("0x42");

            var Flist = new Eina.List <string>();

            Flist.Add("0x0");
            Flist.Add("0x2A");
            Flist.Add("0x42");

            var Fhash = new Eina.Hash <string, string>();

            Fhash["aa"] = "aaa";
            Fhash["bb"] = "bbb";
            Fhash["cc"] = "ccc";

            var Fiterator = ((Eina.Array <string>)Farray).GetIterator();
            var Faccessor = ((Eina.Array <string>)Farray).GetAccessor();

            var Fany_value = new Eina.Value(Eina.ValueType.Double);

            Fany_value.Set(-9007199254740992.0);

            var Fany_value_ref = new Eina.Value(Eina.ValueType.String);

            Fany_value_ref.Set("abc");

            var Fbinbuf = new Eina.Binbuf();

            Fbinbuf.Append(126);

            var Fslice = new Eina.Slice(Eina.MemoryNative.Alloc(1), (UIntPtr)1);

            Marshal.WriteByte(Fslice.Mem, 125);

            var Fobj = new Dummy.Numberwrapper();

            Fobj.Number = 42;

            return(new Dummy.StructComplex(
                       farray: Farray,
                       flist: Flist,
                       fhash: Fhash,
                       fiterator: Fiterator,
                       faccessor: Faccessor,
                       fanyValue: Fany_value,
                       fanyValueRef: Fany_value_ref,
                       fbinbuf: Fbinbuf,
                       fslice: Fslice,
                       fobj: Fobj
                       ));
        }
Esempio n. 5
0
        public bool binbuf_return_still_usable()
        {
            bool r = binbuf_return_binbuf.GetBytes().SequenceEqual(BaseSequence.Values());

            r = r && binbuf_return_binbuf.Own;

            binbuf_return_binbuf.Dispose();
            binbuf_return_binbuf = null;

            return(r);
        }
Esempio n. 6
0
        override public bool EinaBinbufOutOwn(out Eina.Binbuf binbuf)
        {
            binbuf_out_own_flag = true;

            binbuf = new Eina.Binbuf();
            binbuf.Append(33);

            binbuf_out_own_binbuf = binbuf;

            return(true);
        }
Esempio n. 7
0
        public bool binbuf_in_own_still_usable()
        {
            bool r = binbuf_in_own_binbuf.GetBytes().SequenceEqual(new byte[] { 43, 42, 0x0, 0x2A, 0x42, 33 });

            r = r && binbuf_in_own_binbuf.Own;

            binbuf_in_own_binbuf.Dispose();
            binbuf_in_own_binbuf = null;

            return(r);
        }
Esempio n. 8
0
        override public Eina.Binbuf EinaBinbufReturnOwn()
        {
            binbuf_return_own_flag = true;

            var binbuf = new Eina.Binbuf();

            binbuf.Append(33);

            binbuf_return_own_binbuf = binbuf;

            return(binbuf);
        }
Esempio n. 9
0
        override public bool EinaBinbufInOwn(Eina.Binbuf binbuf)
        {
            binbuf_in_own_flag = true;

            bool r = binbuf.GetBytes().SequenceEqual(BaseSequence.Values());

            r = r && binbuf.Own;

            binbuf.Insert(42, 0);
            binbuf.Insert(43, 0);
            binbuf.Append(33);

            binbuf_in_own_binbuf = binbuf;

            return(r);
        }
Esempio n. 10
0
 /// <summary>
 ///   Appends a Binbuf to the buffer.
 /// <para>Since EFL 1.23.</para>
 /// </summary>
 /// <param name="bb">The buffer to be appended.</param>
 /// <returns>true on success, false if data could not be appended.</returns>
 public bool Append(Binbuf bb)
 {
     Contract.Requires(bb != null, nameof(bb));
     return(0 != eina_binbuf_append_buffer(Handle, bb.Handle));
 }
Esempio n. 11
0
 public bool Append(Binbuf bb)
 {
     return(0 != eina_binbuf_append_buffer(Handle, bb.Handle));
 }