dump struct/class in c++11 mapping

[Gavin-Lau]

In our usage, there is a case: we need to convert hundreds of structs/classes(most with nesting， some has optional member) defined with ICE into log files that can be viewed by end users.
we known that the Protobuf lib, we can use "SerializeToString()" to achieve this, are there any methods that might help me out in ice？

We have already tried using ：
member function：ice_tuple()
micro： "#define PRINT_VARIABLE_NAME_AND_VALUE(variable) std::cout << #variable << " = " << variable << std::endl; "
but it still cannot be well adapted to the optional and nested situations.

[bernardnormier]

Ice C++ does not currently provide a way to "print" a struct or class instance.

Ice C# in Ice 3.8 provides this feature indirectly for structs - Slice structs are mapped to C# record (class or struct), and a C# record has a synthesized ToString method.

For C++, using ice_tuple() or the Ice serialization framework does not work for printing. The Ice encoding is a compact encoding that doesn't include the field names - while here, for readability, you want the field names in your output.

A solution is to write your own "print" function for each generated C++ struct, for example:

// C++
// in the same namespace as MyStruct
std::ostream& operator<<(std::ostream&, const MyStruct&);

// implementation shows field names + field values, possibly type name too

Since you have hundreds of these structs, the best would be to update the Slice compiler (slice2cpp) to generate these "print" functions for you. It would be more maintainable. I would also suggest to make this generation opt-in to avoid code bloat, for example:

// Slice
["cpp:printable"] // instructs the Slice compiler to generate operator<< to print this struct
struct Foo { ... }

You could look at the C# record ToString for a possible representation:
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record#built-in-formatting-for-display

[Gavin-Lau]

I use C# AOT to publish dll ,here are my steps:

1. use dotnet create C# lib:

dotnet new classlib -n iceAotLib

2. in project iceAotLib, here is main code

    public class Class1
    {
        // pString is filled in c++ dll caller, generated by outstream,
       //  len is outstream.finished byte array size
        [UnmanagedCallersOnly(EntryPoint = "ToString")]
        public static IntPtr ToString(IntPtr pString, int len)
        {
            Ice.Communicator comu = Ice.Util.initialize();

            Byte[] buf = ConvertCharArrayToByteArray(pString, len);

            Ice.InputStream inStream = new Ice.InputStream(comu, buf1);

            var cb = new ReadValueCallback();
            inStream.readValue(cb.Invoke);
            inStream.readPendingValues();

            var c = cb.Obj as Demo.User;
            string? jsonString = c.ToString();
            Console.WriteLine(jsonString);
            IntPtr sumPointer = Marshal.StringToCoTaskMemAnsi(jsonString);
            return sumPointer;
        }

        static byte[] ConvertCharArrayToByteArray(IntPtr charArrayPtr, int len)
        {
            byte[] byteArray = new byte[len];
            for (int i = 0; i < len; i++)
            {
                byteArray[i] = Marshal.ReadByte(charArrayPtr, i);
            }

            return byteArray;
        }

        internal class ReadValueCallback
        {
            public void Invoke(Ice.Value obj)
            {
                this.Obj = obj;
            }

            internal Ice.Value Obj;
        }
    }

}

3. dotnet publish

here is ice define

module Demo
{
  class Test2
  {
      int id;
      string name;
      float score;
      optional(1) string phone;
  }
  sequence<Test2> Test2Seq;

  class User
  {
      int id;
      string name;
      float score;
      Test2Seq test2Seq;
  }
}

However, problems were encountered during the testing process.

[bernardnormier]

We would need your test (in C++) to reproduce it. Ice 3.7 should work with AOT, even though we haven't tested it.

If you want to programmatically decode a Slice-encoded buffer in C#, the new Slice assembly that ships with IceRPC provides a more elegant API.
https://www.nuget.org/packages/ZeroC.Slice#readme-body-tab

However, you would need to convert your .ice files into .slice files and we have not released the ice2slice tool yet.

[Gavin-Lau]

lots of ice files are using, converting .ice files to .slice files involves a relatively large amount of work. So we prefer to continue using .ice files.

here is the c++ caller code：

#include <iostream>
#include <Windows.h>
#include "Printer.h"
#include <Ice/Version.h>

typedef void*(*ToStringFunction)(void*, int);
ToStringFunction toString = nullptr;

int libloader()
{
    HMODULE hModule = LoadLibraryA("C:/code/iceAotLib/bin/x64/Release/net9.0/win-x64/publish/iceAotLib.dll");
    if (hModule == NULL) {
        std::cerr << "invalid DLL" << std::endl;
        return 1;
    }
    
    toString = (ToStringFunction)GetProcAddress(hModule, "aotsample_add");
    if (toString == NULL) {
        std::cerr << "invalid addr" << std::endl;
        return 1;
    }
    // FreeLibrary(hModule);
}

int struct2Bytes()
{ 
    std::vector<unsigned char> result;
    char buf[200] = { 0 };
    Demo::User user1;
    user1.id = 100;
    user1.name = "lisi";
    user1.score = 100.05;
    auto test1 = std::make_shared<Demo::Test2>();
    test1->id = 200;
    test1->name = "zhangsan";
    test1->phone = std::string("13578451262");

    auto test2 = std::make_shared<Demo::Test2>();
    test1->id = 300;
    test1->name = "wangwu";

    user1.test2Seq.push_back(test1);
    user1.test2Seq.push_back(test2);
    Ice::OutputStream out;

    Ice::StreamWriter<::Demo::User, Ice::OutputStream>().write(&out, user1);
    //out.writeAll(user1);
    out.finished(result);


    int count = 0;
    for (const auto& ch : result)
    {
        buf[count++] = ch;
        std::cout << "***" << (int)ch << "***" << std::endl;
    }
    char* ret = (char*)toString((void*)buf, count);
    std::cout << strlen(ret) << std::endl;
    return 0;
}

int main(int argc, char* argv[])
{
    libloader();
    struct2Bytes();
    return 0;
}

it works when user is struct

[pepone]

Ice classes need to be allocated in the heap, you should use make_shared<Demo::User1>. The C++ marshaling code should look more like:

    auto user1 = std::make_shared<Demo::User>();
    user1->id = 100;
    user1->name = "lisi";
    user1->score = 100.05;

    auto test1 = std::make_shared<Demo::Test2>();
    test1->id = 200;
    test1->name = "zhangsan";
    test1->phone = std::string("13578451262");

    auto test2 = std::make_shared<Demo::Test2>();
    test2->id = 300;
    test2->name = "wangwu";

    user1->test2Seq.push_back(test1);
    user1->test2Seq.push_back(test2);

    Ice::OutputStream out;
    out.write(user1);
    out.writePendingValues();
    out.finished(result);

[Gavin-Lau]

I've also noticed that the 3.8 version is still being updated very frequently. When is it estimated to be released?

[bernardnormier]

Yes, we're making good progress towards 3.8, but there is a still a lot of work to do. We want to release it early next year.