|
Rene Pilon wrote: The idea here is to see if you can open it - and view all the contents (and then close it after of course).
Your guess was right on. It is definitely a problems with the input file.
I added code to open and display the xps just prior to conversion. The default win 8 reader was unable to open the file: "There is a problem with the file format".
This indicates to me that the xps is not fully formed yet for whatever reason.
A great help, thank you.
I'll try to see what's holding up the xps process and let you know the resolution.
|
|
|
|
|
The file produced by MS XPS printer is inaccessible to even file copy.
Yet, the very same xps file can be attached and sent via email.
I attempted to have the program copy the original file after it was sent to email since it is obviously closed and ready for MAPI to use. The emailed version produced a perfectly usable attachment. But then, CopyFile results in ERROR_ACCESS_DENIED. Setting file attribute to "normal" results in the same inability to use the file.
I used:
if ( CopyFile(original.xps,new.xps,TRUE) )
The Email process is making a copy of the file, so why can't CopyFile? Any ideas? I'm at a loss why this xps is so resistant.
|
|
|
|
|
What happens when you run that directly in a command window?
Veni, vidi, abiit domum
|
|
|
|
|
Thanks for responding,
When run from the command line it executes perfectly.
|
|
|
|
|
I want to define a 3D array like this:
Type ary[3][6][7];
Is it possible in C++? I'm using Visual Studio 2010, Boost library is not allowed. If it's possible, please tell me how to initialize each dimension?
|
|
|
|
|
You cannot do that since an array must be typed at its declaration, and that defines the type of each element in the array. You could declare an array of unsigned int and then use casts to set different types in some cells, but it would still be somewhat confusing. Perhaps you should explain what problem you are trying to solve.
Veni, vidi, abiit domum
|
|
|
|
|
+5... when you need to support multiple types, use the largest (byte-wise) and cast... but yes, it may be a bit confusing to others reading the code
|
|
|
|
|
Thanks. Personally, I think it's a daft idea.
Veni, vidi, abiit domum
|
|
|
|
|
You seem to understand the question as storing elements of different types, but I think the request is about using alternate types of index values. See my response.
GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)
|
|
|
|
|
Stefan_Lang wrote: You seem to understand the question as storing elements of different types Well that's what the OP asked for.
Veni, vidi, abiit domum
|
|
|
|
|
(Wathever you want to do) it doesn't look possible.
Veni, vidi, vici.
|
|
|
|
|
If you mean that the type of the index value needs to be different, then the only way to achieve this is defining your own subscript operator overloads, and that means you need to define your own array class(es).
Here's an example of how to define and use such overloads to create a 3D array like you describe:
enum EMyColors {
C_RED,
C_GREEN,
C_YELLOW
};
template <class Base, int n_elements>
class CMyArray1 {
std::vector<Base> values;
public:
CMyArray1() : values(n_elements) {} Base& operator[](const wchar_t wc) {
size_t index = wc - L'a'; assert(index < values.size());
return values[index];
}
};
template <class Base, int n_vectors, int n_elements>
class CMyArray2 {
std::vector< CMyArray1<Base, n_elements> > vectors;
public:
CMyArray2() : vectors(n_vectors) {} CMyArray1<Base, n_elements>& operator[](int i) {
size_t index = i - 1; assert(index < vectors.size());
return vectors[index];
}
};
template <class Base, int n_arrays, int n_vectors, int n_elements>
class CMyArray3 {
std::vector< CMyArray2<Base, n_vectors, n_elements> > arrays;
public:
CMyArray3() : arrays(n_arrays) {} CMyArray2<Base, n_vectors, n_elements>& operator[](EMyColors c) {
size_t index;
switch (c) {
case C_RED:
index = 0;
break;
case C_GREEN:
index = 1;
break;
default:
index = 2;
break;
}
return arrays[index];
}
};
int foo() {
CMyArray3<int, 3, 5, 8> my_array;
my_array[C_GREEN][3][L'c'] = 17;
}
GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)
|
|
|
|
|
An excellent and creative solution!!
The difficult we do right away...
...the impossible takes slightly longer.
|
|
|
|
|
char *** array; and allocate it.
|
|
|
|
|
Simply define the needed datatypes as UNION and make your array of the union type:
enum MyEnum { X, Y, Z };
union MyUnion {
MyEnum _Enum;
int _Int;
const wchar *_Pwchar;
};
MyUnion ary[3][6][7];
|
|
|
|
|
Hi,
Created software for electric switch (one directional) with UPD protocol. At first I created both sides with c#. Worked well but slow, had to restrain my "Transmitter" for the receiver to collect all relevant data. Now for better performance I program a native receiver. All is going well except the "recv" and the "recvfrom" methods only receive 517 bytes of the package size transmitted: (Maximal UDP)65507. How can I receive maximal upd package with a blocking socket?
|
|
|
|
|
You need to keep receiving until there is no more data. TCP and UDP messages get broken up to send across the wire, so you will not always receive the complete message in one go.
Veni, vidi, abiit domum
|
|
|
|
|
UDP messages will not be broken up. But TCP will mostly (possibly except when Nagle is turned off).
Gisle V.
# rm -vf /bin/laden
/bin/rm: success
|
|
|
|
|
Thanks, you are right of course.
Veni, vidi, abiit domum
|
|
|
|
|
Hi,
This is incorrect if the packet is transmitted over IPv4. All packets are subject to fragmentation over IPv4 and governed by smallest MTU in the route. Note that if the DF bit is set the router will *not* fragment the packet and will instead send back an IMCP response containing the message "fragmentation needed and DF set".
It would be correct to say that routers on an ipv6 network do not fragment and instead the MTU is honored at both receiving end points due to PMTUD.
Best Wishes,
-David Delaune
|
|
|
|
|
This might have something to do that UDP Messages get broken up into different UDP Packets.
For example, the message
"Hi, I am a UDP message and I maybe get transmitted as multiple UDP packets"
might be transmitted as
"Hi, I am a UDP mes"
"sage and I maybe get transmitted as multiple U"
"DP packets"
Due to this you might need to read packets until you KNOW that the message has ended, e.g. by using a fixed message length or a defined control character marking the end of the message.
To answer your question: Your socket will remain blocked until the whole message (= every data packet) is received, but you can avoid a block of your whole program by using a separate thread for your socket.
Veni, vidi, caecus | Everything summarizes to Assembly code
|
|
|
|
|
Thanks, can you give a small code example?
|
|
|
|
|
That depends on which framework you will use.
Are you using .Net? MFC? Native C++? Qt?
Veni, vidi, caecus | Everything summarizes to Assembly code
|
|
|
|
|
You just need to create a loop that repeats the recv call untill there is no more data.
Veni, vidi, abiit domum
|
|
|
|
|
Thanks, I'll give it a shot.....
|
|
|
|