summaryrefslogtreecommitdiff
path: root/matlab/src
diff options
context:
space:
mode:
Diffstat (limited to 'matlab/src')
-rw-r--r--matlab/src/IceMatlab/Communicator.cpp81
-rw-r--r--matlab/src/IceMatlab/Init.cpp37
-rw-r--r--matlab/src/IceMatlab/InputStream.cpp224
-rw-r--r--matlab/src/IceMatlab/InputStream.h6
-rw-r--r--matlab/src/IceMatlab/ObjectPrx.cpp20
-rw-r--r--matlab/src/IceMatlab/OutputStream.cpp468
-rw-r--r--matlab/src/IceMatlab/Util.cpp3
-rw-r--r--matlab/src/IceMatlab/icematlab.h91
8 files changed, 176 insertions, 754 deletions
diff --git a/matlab/src/IceMatlab/Communicator.cpp b/matlab/src/IceMatlab/Communicator.cpp
index 0d4208bf9f9..a9a0b02c98f 100644
--- a/matlab/src/IceMatlab/Communicator.cpp
+++ b/matlab/src/IceMatlab/Communicator.cpp
@@ -13,6 +13,7 @@
#include <Ice/Proxy.h>
#include <Ice/OutputStream.h>
#include "icematlab.h"
+#include "ObjectPrx.h"
#include "Util.h"
#define SELF (*(reinterpret_cast<shared_ptr<Ice::Communicator>*>(self)))
@@ -31,12 +32,57 @@ Ice_Communicator__release(void* self)
}
EXPORTED_FUNCTION mxArray*
+Ice_Communicator_identityToString(void* self, mxArray* id)
+{
+ try
+ {
+ Ice::Identity ident;
+ getIdentity(id, ident);
+ return createResultValue(createStringFromUTF8(SELF->identityToString(ident)));
+ }
+ catch(const std::exception& ex)
+ {
+ return createResultException(convertException(ex));
+ }
+ return 0;
+}
+
+EXPORTED_FUNCTION mxArray*
Ice_Communicator_stringToProxy(void* self, const char* s, void** proxy)
{
try
{
shared_ptr<Ice::ObjectPrx> p = SELF->stringToProxy(s);
- *proxy = new shared_ptr<Ice::ObjectPrx>(p);
+ if(p)
+ {
+ *proxy = new shared_ptr<Ice::ObjectPrx>(p);
+ }
+ else
+ {
+ *proxy = 0;
+ }
+ }
+ catch(const std::exception& ex)
+ {
+ return convertException(ex);
+ }
+ return 0;
+}
+
+EXPORTED_FUNCTION mxArray*
+Ice_Communicator_propertyToProxy(void* self, const char* prop, void** proxy)
+{
+ try
+ {
+ shared_ptr<Ice::ObjectPrx> p = SELF->propertyToProxy(prop);
+ if(p)
+ {
+ *proxy = new shared_ptr<Ice::ObjectPrx>(p);
+ }
+ else
+ {
+ *proxy = 0;
+ }
}
catch(const std::exception& ex)
{
@@ -46,6 +92,39 @@ Ice_Communicator_stringToProxy(void* self, const char* s, void** proxy)
}
EXPORTED_FUNCTION mxArray*
+Ice_Communicator_proxyToProperty(void* self, void* proxy, const char* prop)
+{
+ assert(proxy);
+ try
+ {
+ shared_ptr<Ice::ObjectPrx> p = getProxy(proxy);
+ Ice::PropertyDict d = SELF->proxyToProperty(p, prop);
+ return createResultValue(createStringMap(d));
+ }
+ catch(const std::exception& ex)
+ {
+ return createResultException(convertException(ex));
+ }
+ return 0;
+}
+
+EXPORTED_FUNCTION mxArray*
+Ice_Communicator_proxyToString(void* self, void* proxy)
+{
+ assert(proxy);
+ try
+ {
+ shared_ptr<Ice::ObjectPrx> p = getProxy(proxy);
+ return createResultValue(createStringFromUTF8(SELF->proxyToString(p)));
+ }
+ catch(const std::exception& ex)
+ {
+ return createResultException(convertException(ex));
+ }
+ return 0;
+}
+
+EXPORTED_FUNCTION mxArray*
Ice_Communicator_getProperties(void* self, void** props)
{
try
diff --git a/matlab/src/IceMatlab/Init.cpp b/matlab/src/IceMatlab/Init.cpp
index 772647763f1..f67860dbaa7 100644
--- a/matlab/src/IceMatlab/Init.cpp
+++ b/matlab/src/IceMatlab/Init.cpp
@@ -139,7 +139,6 @@ Ice_initialize(mxArray* args, void* propsImpl, void** r)
id.properties = *(reinterpret_cast<shared_ptr<Ice::Properties>*>(propsImpl));
}
- //id.valueFactoryManager = make_shared<ValueFactoryManager>();
//id.logger = make_shared<Logger>(""); // TODO
shared_ptr<Ice::Communicator> c = Ice::initialize(a, id);
@@ -169,13 +168,14 @@ Ice_stringToIdentity(mxArray* s)
}
EXPORTED_FUNCTION mxArray*
-Ice_identityToString(mxArray* id)
+Ice_identityToString(mxArray* id, int mode)
{
try
{
+ Ice::ToStringMode m = static_cast<Ice::ToStringMode>(mode);
Ice::Identity ident;
getIdentity(id, ident);
- return createResultValue(createStringFromUTF8(Ice::identityToString(ident)));
+ return createResultValue(createStringFromUTF8(Ice::identityToString(ident, m)));
}
catch(const std::exception& ex)
{
@@ -184,6 +184,37 @@ Ice_identityToString(mxArray* id)
return 0;
}
+EXPORTED_FUNCTION mxArray*
+Ice_stringVersion()
+{
+ return createResultValue(createStringFromUTF8(ICE_STRING_VERSION));
+}
+
+EXPORTED_FUNCTION mxArray*
+Ice_intVersion(int* v)
+{
+ *v = ICE_INT_VERSION;
+ return 0;
+}
+
+EXPORTED_FUNCTION mxArray*
+Ice_currentEncoding()
+{
+ return createResultValue(createEncodingVersion(Ice::currentEncoding));
+}
+
+EXPORTED_FUNCTION mxArray*
+Ice_currentProtocol()
+{
+ return createResultValue(createProtocolVersion(Ice::currentProtocol));
+}
+
+EXPORTED_FUNCTION mxArray*
+Ice_currentProtocolEncoding()
+{
+ return createResultValue(createEncodingVersion(Ice::currentProtocolEncoding));
+}
+
//
// This function exists so that mex may be used to compile the library. It is not otherwise needed.
//
diff --git a/matlab/src/IceMatlab/InputStream.cpp b/matlab/src/IceMatlab/InputStream.cpp
index 83c7173bcc5..afbc2d147a4 100644
--- a/matlab/src/IceMatlab/InputStream.cpp
+++ b/matlab/src/IceMatlab/InputStream.cpp
@@ -15,7 +15,7 @@
#include "InputStream.h"
#include "Util.h"
-#define SELF (reinterpret_cast<IceMatlab::InputStreamData*>(self))
+#define SELF (reinterpret_cast<InputStreamData*>(self))
using namespace std;
using namespace IceMatlab;
@@ -23,6 +23,12 @@ using namespace IceMatlab;
namespace
{
+struct InputStreamData
+{
+ std::vector<Ice::Byte> data;
+ Ice::InputStream* in;
+};
+
template<typename T>
mxArray*
readSeq(Ice::InputStream* in, mxClassID cls)
@@ -46,51 +52,6 @@ readSeq(Ice::InputStream* in, mxClassID cls)
return 0;
}
-template<typename T>
-mxArray*
-readOpt(Ice::InputStream* in, int tag, mxClassID cls)
-{
- try
- {
- Ice::optional<T> opt;
- in->read(tag, opt);
- if(opt.has_value())
- {
- mxArray* r = mxCreateUninitNumericMatrix(1, 1, cls, mxREAL);
- *(reinterpret_cast<T*>(mxGetData(r))) = opt.value();
- return createResultValue(r);
- }
- }
- catch(const std::exception& ex)
- {
- return createResultException(convertException(ex));
- }
- return 0;
-}
-
-template<typename T>
-mxArray*
-readSeqOpt(Ice::InputStream* in, int tag, mxClassID cls)
-{
- try
- {
- Ice::optional<pair<const T*, const T*>> opt;
- in->read(tag, opt);
- const size_t sz = opt.value().second - opt.value().first;
- if(opt.has_value() && sz > 0)
- {
- mxArray* r = mxCreateUninitNumericMatrix(1, sz / sizeof(T), cls, mxREAL);
- memcpy(reinterpret_cast<T*>(mxGetData(r)), opt.value().first, sz);
- return createResultValue(r);
- }
- }
- catch(const std::exception& ex)
- {
- return createResultException(convertException(ex));
- }
- return 0;
-}
-
}
void*
@@ -153,47 +114,6 @@ Ice_InputStream_readBoolSeq(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readBoolOpt(void* self, int tag)
-{
- try
- {
- Ice::optional<bool> opt;
- SELF->in->read(tag, opt);
- if(opt.has_value())
- {
- return createResultValue(mxCreateLogicalScalar(opt.value()));
- }
- }
- catch(const std::exception& ex)
- {
- return createResultException(convertException(ex));
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readBoolSeqOpt(void* self, int tag)
-{
- try
- {
- Ice::optional<pair<const bool*, const bool*>> opt;
- SELF->in->read(tag, opt);
- const size_t sz = opt.value().second - opt.value().first;
- if(opt.has_value() && sz > 0)
- {
- mxArray* r = mxCreateLogicalMatrix(1, sz);
- memcpy(mxGetLogicals(r), opt.value().first, sz);
- return createResultValue(r);
- }
- }
- catch(const std::exception& ex)
- {
- return createResultException(convertException(ex));
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_InputStream_readByte(void* self, unsigned char* v)
{
try
@@ -216,18 +136,6 @@ Ice_InputStream_readByteSeq(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readByteOpt(void* self, int tag)
-{
- return readOpt<Ice::Byte>(SELF->in, tag, mxUINT8_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readByteSeqOpt(void* self, int tag)
-{
- return readSeqOpt<Ice::Byte>(SELF->in, tag, mxUINT8_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_InputStream_readShort(void* self, short* v)
{
try
@@ -248,18 +156,6 @@ Ice_InputStream_readShortSeq(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readShortOpt(void* self, int tag)
-{
- return readOpt<short>(SELF->in, tag, mxINT16_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readShortSeqOpt(void* self, int tag)
-{
- return readSeqOpt<short>(SELF->in, tag, mxINT16_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_InputStream_readInt(void* self, int* v)
{
try
@@ -280,18 +176,6 @@ Ice_InputStream_readIntSeq(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readIntOpt(void* self, int tag)
-{
- return readOpt<int>(SELF->in, tag, mxINT32_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readIntSeqOpt(void* self, int tag)
-{
- return readSeqOpt<int>(SELF->in, tag, mxINT32_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_InputStream_readLong(void* self, long long* v)
{
try
@@ -312,18 +196,6 @@ Ice_InputStream_readLongSeq(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readLongOpt(void* self, int tag)
-{
- return readOpt<long long>(SELF->in, tag, mxINT64_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readLongSeqOpt(void* self, int tag)
-{
- return readSeqOpt<long long>(SELF->in, tag, mxINT64_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_InputStream_readFloat(void* self, float* v)
{
try
@@ -344,18 +216,6 @@ Ice_InputStream_readFloatSeq(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readFloatOpt(void* self, int tag)
-{
- return readOpt<float>(SELF->in, tag, mxSINGLE_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readFloatSeqOpt(void* self, int tag)
-{
- return readSeqOpt<float>(SELF->in, tag, mxSINGLE_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_InputStream_readDouble(void* self, double* v)
{
try
@@ -376,18 +236,6 @@ Ice_InputStream_readDoubleSeq(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readDoubleOpt(void* self, int tag)
-{
- return readOpt<double>(SELF->in, tag, mxDOUBLE_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readDoubleSeqOpt(void* self, int tag)
-{
- return readSeqOpt<double>(SELF->in, tag, mxDOUBLE_CLASS);
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_InputStream_readString(void* self)
{
string s;
@@ -419,43 +267,6 @@ Ice_InputStream_readStringSeq(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readStringOpt(void* self, int tag)
-{
- try
- {
- Ice::optional<string> opt;
- SELF->in->read(tag, opt);
- if(opt.has_value())
- {
- return createResultValue(createStringFromUTF8(opt.value()));
- }
- }
- catch(const std::exception& ex)
- {
- return createResultException(convertException(ex));
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readStringSeqOpt(void* self, int tag)
-{
- try
- {
- if(SELF->in->readOptional(tag, Ice::OptionalFormat::FSize))
- {
- SELF->in->skip(4);
- return Ice_InputStream_readStringSeq(self);
- }
- }
- catch(const std::exception& ex)
- {
- return createResultException(convertException(ex));
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_InputStream_skip(void* self, int n)
{
try
@@ -535,20 +346,11 @@ Ice_InputStream_readProxy(void* self, void** r)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readProxyOpt(void* self, int tag, void** r)
+Ice_InputStream_readEnum(void* self, int maxValue, int* r)
{
try
{
- Ice::optional<shared_ptr<Ice::ObjectPrx>> opt;
- SELF->in->readAll({tag}, opt);
- if(opt.has_value())
- {
- *r = new shared_ptr<Ice::ObjectPrx>(opt.value());
- }
- else
- {
- *r = 0;
- }
+ *r = SELF->in->readEnum(maxValue);
}
catch(const std::exception& ex)
{
@@ -558,11 +360,11 @@ Ice_InputStream_readProxyOpt(void* self, int tag, void** r)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_readEnum(void* self, int maxValue, int* r)
+Ice_InputStream_pos(void* self, unsigned int* pos)
{
try
{
- *r = SELF->in->readEnum(maxValue);
+ *pos = SELF->in->pos();
}
catch(const std::exception& ex)
{
@@ -572,11 +374,11 @@ Ice_InputStream_readEnum(void* self, int maxValue, int* r)
}
EXPORTED_FUNCTION mxArray*
-Ice_InputStream_pos(void* self, unsigned int* pos)
+Ice_InputStream_setPos(void* self, unsigned int pos)
{
try
{
- *pos = SELF->in->pos();
+ SELF->in->pos(pos);
}
catch(const std::exception& ex)
{
diff --git a/matlab/src/IceMatlab/InputStream.h b/matlab/src/IceMatlab/InputStream.h
index a801d6a5cb4..f86b1121c9a 100644
--- a/matlab/src/IceMatlab/InputStream.h
+++ b/matlab/src/IceMatlab/InputStream.h
@@ -12,12 +12,6 @@
namespace IceMatlab
{
-struct InputStreamData
-{
- std::vector<Ice::Byte> data;
- Ice::InputStream* in;
-};
-
//
// Consumes the vector.
//
diff --git a/matlab/src/IceMatlab/ObjectPrx.cpp b/matlab/src/IceMatlab/ObjectPrx.cpp
index 0bdb8c32087..2c2145ced2f 100644
--- a/matlab/src/IceMatlab/ObjectPrx.cpp
+++ b/matlab/src/IceMatlab/ObjectPrx.cpp
@@ -13,6 +13,7 @@
#include "icematlab.h"
#include "Future.h"
#include "InputStream.h"
+#include "ObjectPrx.h"
#include "Util.h"
#define DEREF(x) (*(reinterpret_cast<shared_ptr<Ice::ObjectPrx>*>(x)))
@@ -201,6 +202,12 @@ GetConnectionFuture::isFinished() const
}
+shared_ptr<Ice::ObjectPrx>
+IceMatlab::getProxy(void* p)
+{
+ return DEREF(p);
+}
+
extern "C"
{
@@ -391,13 +398,6 @@ Ice_ObjectPrx_ice_toString(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_ObjectPrx_ice_getCommunicator(void* self, void** r)
-{
- *r = new shared_ptr<Ice::Communicator>(SELF->ice_getCommunicator());
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_ObjectPrx_ice_getIdentity(void* self)
{
return createResultValue(createIdentity(SELF->ice_getIdentity()));
@@ -601,14 +601,14 @@ Ice_ObjectPrx_ice_connectionCached(void* self, unsigned char v, void** r)
}
EXPORTED_FUNCTION mxArray*
-Ice_ObjectPrx_ice_getEndpointSelection(void* self, Ice_EndpointSelectionType* r)
+Ice_ObjectPrx_ice_getEndpointSelection(void* self, int* r)
{
- *r = SELF->ice_getEndpointSelection() == Ice::EndpointSelectionType::Random ? Random : Ordered;
+ *r = static_cast<int>(SELF->ice_getEndpointSelection());
return 0;
}
EXPORTED_FUNCTION mxArray*
-Ice_ObjectPrx_ice_endpointSelection(void* self, Ice_EndpointSelectionType v, void** r)
+Ice_ObjectPrx_ice_endpointSelection(void* self, int v, void** r)
{
try
{
diff --git a/matlab/src/IceMatlab/OutputStream.cpp b/matlab/src/IceMatlab/OutputStream.cpp
index 46dee32dc62..d72957ee86c 100644
--- a/matlab/src/IceMatlab/OutputStream.cpp
+++ b/matlab/src/IceMatlab/OutputStream.cpp
@@ -18,88 +18,12 @@
using namespace std;
using namespace IceMatlab;
-namespace
-{
-
-typedef std::map<mxArray*, shared_ptr<Ice::Value>> ValueMap;
-
-//
-// A Closure instance is associated with an OutputStream whenever values are marshaled.
-//
-struct Closure
-{
- ValueMap valueMap;
- mxArray* stream;
-};
-
-//
-// ValueWriter wraps a Matlab object for marshaling.
-//
-class ValueWriter : public Ice::Value
-{
-public:
-
- ValueWriter(mxArray*);
-
- virtual void ice_preMarshal();
-
- virtual void _iceWrite(Ice::OutputStream*) const;
- virtual void _iceRead(Ice::InputStream*);
-
-protected:
-
- virtual shared_ptr<Ice::Value> _iceCloneImpl() const;
-
-private:
-
- mxArray* _value;
-};
-
-ValueWriter::ValueWriter(mxArray* v) :
- _value(v)
-{
-}
-
-void
-ValueWriter::ice_preMarshal()
-{
- mexCallMATLAB(0, 0, 1, &_value, "ice_preMarshal");
-}
-
-void
-ValueWriter::_iceWrite(Ice::OutputStream* os) const
-{
- Closure* c = reinterpret_cast<Closure*>(os->getClosure());
- assert(c);
-
- mxArray* params[2];
- params[0] = _value;
- params[1] = c->stream;
- mexCallMATLAB(0, 0, 2, params, "iceWrite_");
-}
-
-void
-ValueWriter::_iceRead(Ice::InputStream*)
-{
- assert(false);
-}
-
-shared_ptr<Ice::Value>
-ValueWriter::_iceCloneImpl() const
-{
- return nullptr;
-}
-
-}
-
extern "C"
{
EXPORTED_FUNCTION mxArray*
Ice_OutputStream__release(void* self)
{
- Closure* c = reinterpret_cast<Closure*>(SELF->getClosure());
- delete c;
delete SELF;
return 0;
}
@@ -119,20 +43,6 @@ Ice_OutputStream_writeBool(void* self, unsigned char v)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeBoolOpt(void* self, int tag, unsigned char v)
-{
- try
- {
- SELF->writeAll({tag}, IceUtil::Optional<bool>(v == 1));
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeBoolSeq(void* self, const unsigned char* v, int size)
{
const bool* p = reinterpret_cast<const bool*>(v);
@@ -148,24 +58,6 @@ Ice_OutputStream_writeBoolSeq(void* self, const unsigned char* v, int size)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeBoolSeqOpt(void* self, int tag, const unsigned char* v, int size)
-{
- const bool* p = reinterpret_cast<const bool*>(v);
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::VSize))
- {
- SELF->write(p, p + size);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeByte(void* self, unsigned char v)
{
try
@@ -180,20 +72,6 @@ Ice_OutputStream_writeByte(void* self, unsigned char v)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeByteOpt(void* self, int tag, unsigned char v)
-{
- try
- {
- SELF->writeAll({tag}, IceUtil::Optional<Ice::Byte>(static_cast<Ice::Byte>(v)));
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeByteSeq(void* self, const unsigned char* v, int size)
{
const Ice::Byte* p = reinterpret_cast<const Ice::Byte*>(v);
@@ -209,24 +87,6 @@ Ice_OutputStream_writeByteSeq(void* self, const unsigned char* v, int size)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeByteSeqOpt(void* self, int tag, const unsigned char* v, int size)
-{
- const Ice::Byte* p = reinterpret_cast<const Ice::Byte*>(v);
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::VSize))
- {
- SELF->write(p, p + size);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeShort(void* self, short v)
{
try
@@ -241,20 +101,6 @@ Ice_OutputStream_writeShort(void* self, short v)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeShortOpt(void* self, int tag, short v)
-{
- try
- {
- SELF->writeAll({tag}, IceUtil::Optional<short>(v));
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeShortSeq(void* self, const short* v, int size)
{
try
@@ -269,23 +115,6 @@ Ice_OutputStream_writeShortSeq(void* self, const short* v, int size)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeShortSeqOpt(void* self, int tag, const short* v, int size)
-{
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::VSize))
- {
- SELF->write(v, v + size);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeInt(void* self, int v)
{
try
@@ -300,20 +129,6 @@ Ice_OutputStream_writeInt(void* self, int v)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeIntOpt(void* self, int tag, int v)
-{
- try
- {
- SELF->writeAll({tag}, IceUtil::Optional<int>(v));
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeIntSeq(void* self, const int* v, int size)
{
try
@@ -328,23 +143,6 @@ Ice_OutputStream_writeIntSeq(void* self, const int* v, int size)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeIntSeqOpt(void* self, int tag, const int* v, int size)
-{
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::VSize))
- {
- SELF->write(v, v + size);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeLong(void* self, long long v)
{
try
@@ -359,20 +157,6 @@ Ice_OutputStream_writeLong(void* self, long long v)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeLongOpt(void* self, int tag, long long v)
-{
- try
- {
- SELF->writeAll({tag}, IceUtil::Optional<long long>(v));
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeLongSeq(void* self, const long long* v, int size)
{
try
@@ -387,23 +171,6 @@ Ice_OutputStream_writeLongSeq(void* self, const long long* v, int size)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeLongSeqOpt(void* self, int tag, const long long* v, int size)
-{
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::VSize))
- {
- SELF->write(v, v + size);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeFloat(void* self, float v)
{
try
@@ -418,20 +185,6 @@ Ice_OutputStream_writeFloat(void* self, float v)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeFloatOpt(void* self, int tag, float v)
-{
- try
- {
- SELF->writeAll({tag}, IceUtil::Optional<float>(v));
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeFloatSeq(void* self, const float* v, int size)
{
try
@@ -446,23 +199,6 @@ Ice_OutputStream_writeFloatSeq(void* self, const float* v, int size)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeFloatSeqOpt(void* self, int tag, const float* v, int size)
-{
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::VSize))
- {
- SELF->write(v, v + size);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeDouble(void* self, double v)
{
try
@@ -477,20 +213,6 @@ Ice_OutputStream_writeDouble(void* self, double v)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeDoubleOpt(void* self, int tag, double v)
-{
- try
- {
- SELF->writeAll({tag}, IceUtil::Optional<double>(v));
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeDoubleSeq(void* self, const double* v, int size)
{
try
@@ -505,23 +227,6 @@ Ice_OutputStream_writeDoubleSeq(void* self, const double* v, int size)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeDoubleSeqOpt(void* self, int tag, const double* v, int size)
-{
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::VSize))
- {
- SELF->write(v, v + size);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeString(void* self, mxArray* str)
{
try
@@ -536,23 +241,6 @@ Ice_OutputStream_writeString(void* self, mxArray* str)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeStringOpt(void* self, int tag, mxArray* str)
-{
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::VSize))
- {
- SELF->write(getStringFromUTF16(str), false);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeStringSeq(void* self, mxArray* v)
{
try
@@ -589,29 +277,6 @@ Ice_OutputStream_writeStringSeq(void* self, mxArray* v)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeStringSeqOpt(void* self, int tag, mxArray* v)
-{
- try
- {
- if(SELF->writeOptional(tag, Ice::OptionalFormat::FSize))
- {
- Ice::OutputStream::size_type pos = SELF->startSize();
- mxArray* ex = Ice_OutputStream_writeStringSeq(self, v);
- if(ex)
- {
- return ex;
- }
- SELF->endSize(pos);
- }
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeSize(void* self, int size)
{
try
@@ -645,22 +310,6 @@ Ice_OutputStream_writeProxy(void* self, void* proxy)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeProxyOpt(void* self, int tag, void* proxy)
-{
- assert(proxy); // Wrapper only calls this function for a non-nil value.
- shared_ptr<Ice::ObjectPrx> p = *(reinterpret_cast<shared_ptr<Ice::ObjectPrx>*>(proxy));
- try
- {
- SELF->writeAll({tag}, IceUtil::Optional<shared_ptr<Ice::ObjectPrx>>(p));
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
Ice_OutputStream_writeEnum(void* self, int val, int maxValue)
{
try
@@ -675,88 +324,11 @@ Ice_OutputStream_writeEnum(void* self, int val, int maxValue)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeValue(void* self, mxArray* stream, mxArray* val)
-{
- if(mxIsEmpty(val))
- {
- shared_ptr<Ice::Value> nil = nullptr;
- SELF->write(nil);
- return 0;
- }
-
- //
- // Attach a Closure instance to the stream upon writing the first non-nil Value.
- //
- Closure* c = reinterpret_cast<Closure*>(SELF->getClosure());
- if(!c)
- {
- c = new Closure;
- c->stream = stream;
- SELF->setClosure(c);
- }
-
- //
- // We're assuming that a mxArray pointer uniquely identifies an object. We use the closure's map to
- // track the instances.
- //
- shared_ptr<Ice::Value> w;
- ValueMap::iterator p = c->valueMap.find(val);
- if(p == c->valueMap.end())
- {
- w = make_shared<ValueWriter>(val);
- c->valueMap.insert(ValueMap::value_type(val, w));
- }
- else
- {
- w = p->second;
- }
-
- try
- {
- SELF->write(w);
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeValueOpt(void* self, int tag, mxArray* stream, mxArray* val)
-{
- //
- // We assume an empty value means an unset optional (as opposed to an optional set to a null value).
- //
- if(!mxIsEmpty(val) && SELF->writeOptional(tag, Ice::OptionalFormat::Class))
- {
- return Ice_OutputStream_writeValue(self, stream, val);
- }
-
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_startEncapsulation(void* self)
-{
- try
- {
- SELF->startEncapsulation();
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
- return 0;
-}
-
-EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_startEncapsulationWithFormat(void* self, Ice_FormatType t)
+Ice_OutputStream_startSize(void* self, unsigned int* pos)
{
- Ice::FormatType type = static_cast<Ice::FormatType>(t);
try
{
- SELF->startEncapsulation(SELF->getEncoding(), type);
+ *pos = static_cast<unsigned int>(SELF->startSize());
}
catch(const std::exception& ex)
{
@@ -766,11 +338,11 @@ Ice_OutputStream_startEncapsulationWithFormat(void* self, Ice_FormatType t)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_endEncapsulation(void* self)
+Ice_OutputStream_endSize(void* self, unsigned int pos)
{
try
{
- SELF->endEncapsulation();
+ SELF->endSize(pos);
}
catch(const std::exception& ex)
{
@@ -780,11 +352,11 @@ Ice_OutputStream_endEncapsulation(void* self)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_startSlice(void* self, const char* typeId, int compactId, unsigned char last)
+Ice_OutputStream_pos(void* self, unsigned int* pos)
{
try
{
- SELF->startSlice(typeId, compactId, last == 1);
+ *pos = SELF->pos();
}
catch(const std::exception& ex)
{
@@ -794,26 +366,19 @@ Ice_OutputStream_startSlice(void* self, const char* typeId, int compactId, unsig
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_endSlice(void* self)
+Ice_OutputStream_rewriteByte(void* self, unsigned char v, unsigned int pos)
{
- try
- {
- SELF->endSlice();
- }
- catch(const std::exception& ex)
- {
- return convertException(ex);
- }
+ Ice::Byte* dest = &(*(SELF->b.begin() + pos));
+ *dest = v;
return 0;
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_writeOptional(void* self, int tag, Ice_OptionalFormat f, unsigned char* supportsOptionals)
+Ice_OutputStream_rewriteInt(void* self, int v, unsigned int pos)
{
- Ice::OptionalFormat fmt = static_cast<Ice::OptionalFormat>(f);
try
{
- *supportsOptionals = SELF->writeOptional(tag, fmt);
+ SELF->rewrite(v, pos);
}
catch(const std::exception& ex)
{
@@ -823,11 +388,12 @@ Ice_OutputStream_writeOptional(void* self, int tag, Ice_OptionalFormat f, unsign
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_startSize(void* self, unsigned int* pos)
+Ice_OutputStream_writeBlob(void* self, const unsigned char* v, int size)
{
+ const Ice::Byte* p = reinterpret_cast<const Ice::Byte*>(v);
try
{
- *pos = static_cast<unsigned int>(SELF->startSize());
+ SELF->writeBlob(p, size);
}
catch(const std::exception& ex)
{
@@ -837,15 +403,15 @@ Ice_OutputStream_startSize(void* self, unsigned int* pos)
}
EXPORTED_FUNCTION mxArray*
-Ice_OutputStream_endSize(void* self, unsigned int pos)
+Ice_OutputStream_getEncoding(void* self)
{
try
{
- SELF->endSize(pos);
+ return createResultValue(createEncodingVersion(SELF->getEncoding()));
}
catch(const std::exception& ex)
{
- return convertException(ex);
+ return createResultException(convertException(ex));
}
return 0;
}
diff --git a/matlab/src/IceMatlab/Util.cpp b/matlab/src/IceMatlab/Util.cpp
index d4c15b7255e..8414c716f2e 100644
--- a/matlab/src/IceMatlab/Util.cpp
+++ b/matlab/src/IceMatlab/Util.cpp
@@ -66,7 +66,7 @@ IceMatlab::createStringFromUTF8(const string& s)
#else
u16string utf16 = wstring_convert<codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(s.data());
#endif
- mwSize dims[2] = { 1, utf16.size() };
+ mwSize dims[2] = { 1, static_cast<mwSize>(utf16.size()) };
mxArray* r = mxCreateCharArray(2, dims);
mxChar* buf = mxGetChars(r);
int i = 0;
@@ -440,6 +440,7 @@ IceMatlab::convertException(const std::exception& exc)
}
catch(const Ice::UnsupportedEncodingException& e)
{
+ params[idx++] = createStringFromUTF8(e.reason);
params[idx++] = createEncodingVersion(e.bad);
params[idx++] = createEncodingVersion(e.supported);
}
diff --git a/matlab/src/IceMatlab/icematlab.h b/matlab/src/IceMatlab/icematlab.h
index 0b52babf28c..016efe2d633 100644
--- a/matlab/src/IceMatlab/icematlab.h
+++ b/matlab/src/IceMatlab/icematlab.h
@@ -26,10 +26,19 @@ typedef struct mxArray_tag mxArray; // Forward declaration to avoid importing me
EXPORTED_FUNCTION mxArray* Ice_initialize(mxArray*, void*, void**);
EXPORTED_FUNCTION mxArray* Ice_stringToIdentity(mxArray*);
-EXPORTED_FUNCTION mxArray* Ice_identityToString(mxArray*);
+EXPORTED_FUNCTION mxArray* Ice_identityToString(mxArray*, int);
+EXPORTED_FUNCTION mxArray* Ice_stringVersion();
+EXPORTED_FUNCTION mxArray* Ice_intVersion(int*);
+EXPORTED_FUNCTION mxArray* Ice_currentEncoding();
+EXPORTED_FUNCTION mxArray* Ice_currentProtocol();
+EXPORTED_FUNCTION mxArray* Ice_currentProtocolEncoding();
EXPORTED_FUNCTION mxArray* Ice_Communicator__release(void*);
+EXPORTED_FUNCTION mxArray* Ice_Communicator_identityToString(void*, mxArray*);
EXPORTED_FUNCTION mxArray* Ice_Communicator_stringToProxy(void*, const char*, void**);
+EXPORTED_FUNCTION mxArray* Ice_Communicator_propertyToProxy(void*, const char*, void**);
+EXPORTED_FUNCTION mxArray* Ice_Communicator_proxyToProperty(void*, void*, const char*);
+EXPORTED_FUNCTION mxArray* Ice_Communicator_proxyToString(void*, void*);
EXPORTED_FUNCTION mxArray* Ice_Communicator_getProperties(void*, void**);
EXPORTED_FUNCTION mxArray* Ice_Communicator_createOutputStream(void*, mxArray*, void**);
EXPORTED_FUNCTION mxArray* Ice_Communicator_destroy(void*);
@@ -41,12 +50,6 @@ typedef enum
Idempotent
} Ice_OperationMode;
-typedef enum
-{
- Random,
- Ordered
-} Ice_EndpointSelectionType;
-
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx__release(void*);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_equals(void*, void*, unsigned char*);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_createOutputStream(void*, void**);
@@ -58,7 +61,6 @@ EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_invokeAsync(void*, const char*, Ice
void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_invokeAsyncNC(void*, const char*, Ice_OperationMode, void*, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_toString(void*);
-EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getCommunicator(void*, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getIdentity(void*);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_identity(void*, mxArray*, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getContext(void*);
@@ -77,8 +79,8 @@ EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getConnectionId(void*);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_connectionId(void*, const char*, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_isConnectionCached(void*, unsigned char*);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_connectionCached(void*, unsigned char, void**);
-EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getEndpointSelection(void*, Ice_EndpointSelectionType*);
-EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_endpointSelection(void*, Ice_EndpointSelectionType, void**);
+EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getEndpointSelection(void*, int*);
+EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_endpointSelection(void*, int, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getEncodingVersion(void*);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_encodingVersion(void*, mxArray*, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getRouter(void*, void**);
@@ -97,6 +99,8 @@ EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_isBatchOneway(void*, unsigned char*
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_batchOneway(void*, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_isDatagram(void*, unsigned char*);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_datagram(void*, void**);
+EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_isBatchDatagram(void*, unsigned char*);
+EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_batchDatagram(void*, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_compress(void*, unsigned char, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_timeout(void*, int, void**);
EXPORTED_FUNCTION mxArray* Ice_ObjectPrx_ice_getConnection(void*, void**);
@@ -128,114 +132,59 @@ EXPORTED_FUNCTION mxArray* Ice_SentFuture_state(void*);
EXPORTED_FUNCTION mxArray* Ice_SentFuture_cancel(void*);
EXPORTED_FUNCTION mxArray* Ice_SentFuture_check(void*);
-typedef enum
-{
- DefaultFormat,
- CompactFormat,
- SlicedFormat
-} Ice_FormatType;
-
-typedef enum
-{
- OptionalFormatF1 = 0,
- OptionalFormatF2 = 1,
- OptionalFormatF4 = 2,
- OptionalFormatF8 = 3,
- OptionalFormatSize = 4,
- OptionalFormatVSize = 5,
- OptionalFormatFSize = 6,
- OptionalFormatClass = 7
-} Ice_OptionalFormat;
-
EXPORTED_FUNCTION mxArray* Ice_OutputStream__release(void*);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeBool(void*, unsigned char);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeBoolOpt(void*, int, unsigned char);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeBoolSeq(void*, const unsigned char*, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeBoolSeqOpt(void*, int, const unsigned char*, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeByte(void*, unsigned char);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeByteOpt(void*, int, unsigned char);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeByteSeq(void*, const unsigned char*, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeByteSeqOpt(void*, int, const unsigned char*, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeShort(void*, short);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeShortOpt(void*, int, short);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeShortSeq(void*, const short*, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeShortSeqOpt(void*, int, const short*, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeInt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeIntOpt(void*, int, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeIntSeq(void*, const int*, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeIntSeqOpt(void*, int, const int*, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeLong(void*, long long);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeLongOpt(void*, int, long long);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeLongSeq(void*, const long long*, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeLongSeqOpt(void*, int, const long long*, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeFloat(void*, float);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeFloatOpt(void*, int, float);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeFloatSeq(void*, const float*, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeFloatSeqOpt(void*, int, const float*, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeDouble(void*, double);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeDoubleOpt(void*, int, double);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeDoubleSeq(void*, const double*, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeDoubleSeqOpt(void*, int, const double*, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeString(void*, mxArray*);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeStringOpt(void*, int, mxArray*);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeStringSeq(void*, mxArray*);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeStringSeqOpt(void*, int, mxArray*);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeSize(void*, int);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeProxy(void*, void*);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeProxyOpt(void*, int, void*);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeEnum(void*, int, int);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeValue(void*, mxArray*, mxArray*);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeValueOpt(void*, int, mxArray*, mxArray*);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_startEncapsulation(void*);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_startEncapsulationWithFormat(void*, Ice_FormatType);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_endEncapsulation(void*);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_startSlice(void*, const char*, int, unsigned char);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_endSlice(void*);
-EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeOptional(void*, int, Ice_OptionalFormat, unsigned char*);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_startSize(void*, unsigned int*);
EXPORTED_FUNCTION mxArray* Ice_OutputStream_endSize(void*, unsigned int);
+EXPORTED_FUNCTION mxArray* Ice_OutputStream_pos(void*, unsigned int*);
+EXPORTED_FUNCTION mxArray* Ice_OutputStream_rewriteByte(void*, unsigned char, unsigned int);
+EXPORTED_FUNCTION mxArray* Ice_OutputStream_rewriteInt(void*, int, unsigned int);
+EXPORTED_FUNCTION mxArray* Ice_OutputStream_writeBlob(void*, const unsigned char*, int);
+EXPORTED_FUNCTION mxArray* Ice_OutputStream_getEncoding(void*);
EXPORTED_FUNCTION mxArray* Ice_InputStream__release(void*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readBool(void*, unsigned char*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readBoolSeq(void*);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readBoolOpt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readBoolSeqOpt(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readByte(void*, unsigned char*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readByteSeq(void*);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readByteOpt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readByteSeqOpt(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readShort(void*, short*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readShortSeq(void*);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readShortOpt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readShortSeqOpt(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readInt(void*, int*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readIntSeq(void*);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readIntOpt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readIntSeqOpt(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readLong(void*, long long*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readLongSeq(void*);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readLongOpt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readLongSeqOpt(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readFloat(void*, float*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readFloatSeq(void*);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readFloatOpt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readFloatSeqOpt(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readDouble(void*, double*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readDoubleSeq(void*);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readDoubleOpt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readDoubleSeqOpt(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readString(void*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readStringSeq(void*);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readStringOpt(void*, int);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readStringSeqOpt(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_skip(void*, int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_skipSize(void*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_getEncoding(void*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readSize(void*, int*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readProxy(void*, void**);
-EXPORTED_FUNCTION mxArray* Ice_InputStream_readProxyOpt(void*, int, void**);
EXPORTED_FUNCTION mxArray* Ice_InputStream_readEnum(void*, int, int*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_pos(void*, unsigned int*);
+EXPORTED_FUNCTION mxArray* Ice_InputStream_setPos(void*, unsigned int);
EXPORTED_FUNCTION mxArray* Ice_InputStream_size(void*, unsigned int*);
EXPORTED_FUNCTION mxArray* Ice_InputStream_getBytes(void*, unsigned int, unsigned int);
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-04 00:40:12 +0000