~ifolder-dev/simias/trunk-packaging

fprintf(stderr, "%d: accepted %d IP=%d.%d.%d.%d ... ", i, s, (int)(soap.ip>>24)&0xFF, (int)(soap.ip>>16)&0xFF, (int)(soap.ip>>8)&0xFF, (int)soap.ip&0xFF);

soap_serve(&soap); // process RPC skeletons

fprintf(stderr, "served\n");

soap_destroy(&soap);

soap_end(&soap); // clean up

}

soap_done(&soap);

return 0;

}

////////////////////////////////////////////////////////////////////////////////

// Magic Square Algorithm

////////////////////////////////////////////////////////////////////////////////

int ns1__magic(struct soap *soap, int n, matrix *square)

{ int i, j, k, l, key = 2;

if (n < 1)

return soap_sender_fault(soap, "Negative or zero size", "<error xmlns=\"http://tempuri.org/\">The input parameter must be positive</error>");

if (n > 100)

return soap_sender_fault(soap, "size > 100", "<error xmlns=\"http://tempuri.org/\">The input parameter must not be too large</error>");

square->resize(n, n);

for (i = 0; i < n; i++)

for (j = 0; j < n; j++)

(*square)[i][j] = 0;

i = 0;

j = (n-1)/2;

(*square)[i][j] = 1;

while (key <= n*n)

{ if (i-1 < 0)

k = n-1;

else

k = i-1;

if (j-1 < 0)

l = n-1;

else

l = j-1;

if ((*square)[k][l])

i = (i+1) % n;

else

{ i = k;

j = l;

}

(*square)[i][j] = key;

key++;

}

return SOAP_OK;

}

////////////////////////////////////////////////////////////////////////////////

// Class vector Methods

////////////////////////////////////////////////////////////////////////////////

100

101

vector::vector()

102

{ __ptr = 0;

103

__size = 0;

104

}

105

106

vector::vector(int n)

107

{ __ptr = (int*)soap_malloc(soap, n*sizeof(int));

108

__size = n;

109

}

110

111

vector::~vector()

112

{ soap_unlink(soap, this); // not required, but just to make sure if someone calls delete on this

113

}

114

115

void vector::resize(int n)

116

{ int *p;

117

if (__size == n)

118

return;

119

p = (int*)soap_malloc(soap, n*sizeof(int));

120

if (__ptr)

121

{ for (int i = 0; i < (n <= __size ? n : __size); i++)

122

p[i] = __ptr[i];

123

soap_unlink(soap, __ptr);

124

free(__ptr);

125

}

126

__size = n;

127

__ptr = p;

128

}

129

130

int& vector::operator[](int i) const

131

{ if (!__ptr || i < 0 || i >= __size)

132

fprintf(stderr, "Array index out of bounds\n");

133

return (__ptr)[i];

134

}

135

136

////////////////////////////////////////////////////////////////////////////////

137

138

// Class matrix Methods

139

140

////////////////////////////////////////////////////////////////////////////////

141

142

matrix::matrix()

143

{ __ptr = 0;

144

__size = 0;

145

}

146

147

matrix::matrix(int rows, int cols)

148

{ __ptr = soap_new_vector(soap, rows);

149

for (int i = 0; i < cols; i++)

150

__ptr[i].resize(cols);

151

__size = rows;

152

}

153

154

matrix::~matrix()

155

{ soap_unlink(soap, this); // not required, but just to make sure if someone calls delete on this

156

}

157

158

void matrix::resize(int rows, int cols)

159

{ int i;

160

vector *p;

161

if (__size != rows)

162

{ if (__ptr)

163

{ p = soap_new_vector(soap, rows);

164

for (i = 0; i < (rows <= __size ? rows : __size); i++)

165

{ if (this[i].__size != cols)

166

(*this)[i].resize(cols);

167

(p+i)->__ptr = __ptr[i].__ptr;

168

(p+i)->__size = cols;

169

}

170

for (; i < rows; i++)

171

__ptr[i].resize(cols);

172

}

173

else

174

{ __ptr = soap_new_vector(soap, rows);

175

for (i = 0; i < rows; i++)

176

__ptr[i].resize(cols);

177

__size = rows;

178

}

179

}

180

else

181

for (i = 0; i < __size; i++)

182

__ptr[i].resize(cols);

183

}

184

185

vector& matrix::operator[](int i) const

186

{ if (!__ptr || i < 0 || i >= __size)

187

fprintf(stderr, "Array index out of bounds\n");

188

return __ptr[i];

189

}

Older »