I want to sort a set of records using STL's sort() function,
but dont see an easy way to do it.
I have a
char *data;
which has size mn bytes where m is size of the record and
n is the number of records. Both these numbers are known
only dynamically. I have a function less_than that can compare
two records of size m given the pointers to the two records.
Is there an easy way to call STL sort() on this data and sort it.
The data is big and I do NOT want to allocate a list of pointers
of size n or anything linear in size. Assume that except the data,
we do not have much space...
I thought of tricking sort() using a dummy Record class that is
templated using the size of the record...But since m can change
dynamically this doesnt work.
Thanks in advance for your comments,
--Elijah
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]
Jul 22 '05
40 4320
Thanks Ron, I think that is definitely a problem.
But I still "think" it can be done, dont know how to thou...:)
"Ron Natalie" <ro*@sensor.com > wrote in message news:<3f******* *************** *@news.newshost ing.com>... "Jeff Schwab" <je******@comca st.net> wrote in message news:Wo******** ************@co mcast.com...
Writing your own iterators would not be trivial, but probably would be a educational. Having such iterators available would make your data structure compatible with most of the standard library, and might avoid countless future headaches.
The trouble with writing iterators for this problem is that he needs it to be variable size at run time and that the iterators have to be derferenceable and the derefenced types assignable. Add his requirement to not allocate even enough memory to hold pointers to each object, I can't figure out how you could do it.
On Fri, 02 Jan 2004 03:13:26 -0800, Elijah Bailey wrote:
[ Please don't top post, thank you. M4 ]
[ Crossposted to csc++, is this standard complient? ]
[ Short description of the problem ]
We have an array of n*m bytes. It holds n objects of size m. Both are only
known at runtime. For some strange reason we want to sort this using
std::sort. We know there are other solutions, the question is, can it be
done using std::sort.
Constraints: Not clear, but memory seems to be an issue, creating an array
of pointers and sort that is out. "Ron Natalie" <ro*@sensor.com > wrote in message news:<3f******* *************** *@news.newshost ing.com>... "Jeff Schwab" <je******@comca st.net> wrote in message news:Wo******** ************@co mcast.com...
> Writing your own iterators would not be trivial, but probably would > be a educational. Having such iterators available would make your > data structure compatible with most of the standard library, and > might avoid countless future headaches.
The trouble with writing iterators for this problem is that he needs it to be variable size at run time and that the iterators have to be derferenceable and the derefenced types assignable. Add his requirement to not allocate even enough memory to hold pointers to each object, I can't figure out how you could do it.
Thanks Ron, I think that is definitely a problem. But I still "think" it can be done, dont know how to thou...:)
I also think it can be done. However, it requires so much trickery that it
is not interesting to do so. Any of the other options quickly become very
appealing. My approach uses some dynamic memory, but probably less than an
array of pointers would take. The actual amount depends on the number of
copies std::sort makes internally, there is no way around this. I guess
for a typical implementation this would be around log(n) copies, unless
the implementation takes special care to dispose of temporaries. You
cannot count on any of this though.
OK, how can we do it? Obviously every iterator must know the size of the
object it is supposed to handle. The main problems we are facing:
- We cannot create real objects (directly), the size of the real object is
only known at runtime.
- std::sort is allowed to (and most frequently does) make extra copies of
objects.
Asusmptions:
- There are functions to copy these objects and to compare these objects.
- The objects to be sorted don't need special construction or destruction
and can be copied by the previously mentioned routine. They can be
constructed by copying into a new memory area.
- std::sort never uses pointers to objects, only iterators. I think the
standard mandates this, but couldn't find it.
We create a proxy class and let the iterator return proxy objects. These
proxy objects store a pointer to some master descriptor that stores the
location and size of the array and the size of the individual objects. We
could store this in the proxy object itself, but that seems wasteful.
Also, the proxy object stores a void* to store the data for the real
object.
This proxy class is what our iterators value_type is.
Now the proxy object implements some intelligent constructors. I doubt we
need a default constructor, the value type needs to be assignable only
(this follows from the iterator requirements). So we create a constructor
that is used only inside the iterator, it sets the data pointer to point
inside the array at the correct location. If the copy constructor is
called (which would be by std::sort) we dynamically allocate memory to
hold the object and use the copying routine to fill it.
The assignment operator must use the copying routine if the destination is
inside the array. If not, it can either use copy-construct-and-swap or the
copying routine.
The destructor would check if the pointer points inside the array and if
not deletes the object.
Obviously, we need to define an operator< for the proxy objects, this
calls the comparison function above. If we template the proxy objects, we
can use a functor for the comparison, potentially inlining the comaparison
(this would be the only reason to use std::sort anyhow, so it makes
sense).
Looking at the standard, this would fullfill all requirements for
std::sort I could find. Somehow I think I did overlook something here, so
scrutiny by others is appreciated. I also left obvious details out,
obviously :-)
A note on exceptions. This would give the basic guarentee, if the copying
and comparison routines give at least the basic guarentee.
A note on memory usage. Assuming that std::sort holds log(n) copies of
objects internally, this aproach uses less memory than the
sort-array-of-pointers aproach if log(n)*m < n*sizeof(void*) . So this
greatly depends on these variables, but quickly holds for large n and gets
less interesting for large m. Assume sizeof(void*)== 4, we get m <
4n/log(n). For n=100, m should be less than 60. For n=1000, m should be
less than 400. These are gross approximations but should give you a feel.
I hope anyone sees that you must have good reasons to do this. It is ugly,
errorprone, prone to assumptions your implementation of std::sort makes
(in this implementation &*it does not return a pointer to the real object,
any pointer arithmetic will fail), difficult to maintain. There is no real
reason why you should not call qsort in the first place, except as an
accademic exercise.
HTH,
M4
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]
In message <e0************ **************@ posting.google. com>, Elijah
Bailey <ge******@hotma il.com> writes I want to sort a set of records using STL's sort() function, but dont see an easy way to do it.
I have a
char *data;
which has size mn bytes where m is size of the record and n is the number of records. Both these numbers are known only dynamically. I have a function less_than that can compare two records of size m given the pointers to the two records.
Is there an easy way to call STL sort() on this data and sort it. The data is big and I do NOT want to allocate a list of pointers of size n or anything linear in size. Assume that except the data, we do not have much space...
I thought of tricking sort() using a dummy Record class that is templated using the size of the record...But since m can change dynamically this doesnt work.
Sorry to be so slow off the mark.
But if n and m are only known at execution time the array must be
created dynamically which immediately makes me think of using a vector.
The following trivial program demonstrates that.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n, m;
cout << "n and m ";
cin >> n >> m;
vector< vector<char> > a(n, m);
for(int i(0); i != n; ++i){
for(int j(0); j != m; ++j){
a[i][j] = 'a' - i - j;
}
}
for(int i(0); i != n; ++i){
for(int j(0); j != m; ++j){
cout << a[i][j] << " ";
}
cout << '\n';
}
sort(a.begin(), a.end());
cout << "\n\n";
for(int i(0); i != n; ++i){
for(int j(0); j != m; ++j){
cout << a[i][j] << " ";
}
cout << '\n';
}
}
--
Francis Glassborow ACCU
Author of 'You Can Do It!' see http://www.spellen.org/youcandoit
or http://www.robinton.demon.co.uk
Happy Xmas, Hanukkah, Yuletide, Winter/Summer Solstice to all.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]
On 3 Jan 2004 09:59:24 -0500, Francis Glassborow
<fr*****@robint on.demon.co.uk> wrote: In message <e0************ **************@ posting.google. com>, Elijah Bailey <ge******@hotma il.com> writes
Is there an easy way to call STL sort() on this data and sort it. The data is big and I do NOT want to allocate a list of pointers of size n or anything linear in size. Assume that except the data, we do not have much space...
Requirement for no added space proportional to size.
But if n and m are only known at execution time the array must be created dynamically which immediately makes me think of using a vector.
Just use an array of size structs containing three pointers each.
I think you missed the requirements.
John
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]
Francis Glassborow wrote: In message <e0************ **************@ posting.google. com>, Elijah Bailey <ge******@hotma il.com> writes
I want to sort a set of records using STL's sort() function, but dont see an easy way to do it.
I have a
char *data;
which has size mn bytes where m is size of the record and n is the number of records. Both these numbers are known only dynamically. I have a function less_than that can compare two records of size m given the pointers to the two records.
Is there an easy way to call STL sort() on this data and sort it. The data is big and I do NOT want to allocate a list of pointers of size n or anything linear in size. Assume that except the data, we do not have much space...
I thought of tricking sort() using a dummy Record class that is templated using the size of the record...But since m can change dynamically this doesnt work.
Sorry to be so slow off the mark.
But if n and m are only known at execution time the array must be created dynamically which immediately makes me think of using a vector.
This problem was posed by someone who gets handed a char*, and does not
want to copy the data.
I came to almost the same conclusions as Martijn. I don't think
std::sort needs (or uses, in the version shipped with GCC) log_n copies
of data; a few simultaneous copies are, however, needed. I naively
assumed that *no* copies would be needed, and that implementing "swap"
would be sufficient for avoiding the need of any temporaries. Silly me.
Anyway, the code I've got now seems to work *except* that all of the
data get overwritten by one of the values, due to the fact that all
records (even copies made by std::sort) alias the actual data. I'm sure
this could be fixed with a little bit of effort. Please let me know if
there is sufficient interest for me to post the code I've got (546
lines, lots of white space).
-Jeff
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]
In article <pa************ *************** *@remove.this.p art.rtij.nl>,
Martijn Lievaart <m@remove.this. part.rtij.nl> writes On Fri, 02 Jan 2004 03:13:26 -0800, Elijah Bailey wrote:
[ Please don't top post, thank you. M4 ]
[ Crossposted to csc++, is this standard complient? ]
[ Short description of the problem ]
We have an array of n*m bytes. It holds n objects of size m. Both are only known at runtime. For some strange reason we want to sort this using std::sort. We know there are other solutions, the question is, can it be done using std::sort.
Constraints: Not clear, but memory seems to be an issue, creating an array of pointers and sort that is out.
But if n and m are only known at execution time the array must be
created dynamically which immediately makes me think of using a vector.
The following trivial program demonstrates that.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n, m;
cout << "N and m";
cin >> n >> m;
vector< vector<char> > a(n, m);
for(int i(0); i != n; ++i){
for(int j(0); j != m; ++j){
a[i][j] = 'a' - i - j;
}
}
for(int i(0); i != n; ++i){
for(int j(0); j != m; ++j){
cout << a[i][j] << " ";
}
cout << '\n';
}
sort(a.begin(), a.end());
cout << "\n\n";
for(int i(0); i != n; ++i){
for(int j(0); j != m; ++j){
cout << a[i][j] << " ";
}
cout << '\n';
}
}
--
Francis Glassborow ACCU
Author of 'You Can Do It!' see http://www.spellen.org/youcandoit
or http://www.robinton.demon.co.uk
Happy Xmas, Hanukkah, Yuletide, Winter/Summer Solstice to all.
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ] m@remove.this.p art.rtij.nl (Martijn Lievaart) wrote in message news:<pa******* *************** ******@remove.t his.part.rtij.n l>... On Fri, 02 Jan 2004 03:13:26 -0800, Elijah Bailey wrote:
[ Please don't top post, thank you. M4 ]
[ Crossposted to csc++, is this standard complient? ]
[ Short description of the problem ]
We have an array of n*m bytes. It holds n objects of size m. Both are only known at runtime. For some strange reason we want to sort this using std::sort. We know there are other solutions, the question is, can it be done using std::sort.
Thanks Martijn. This is a much better description than i came up with.
Constraints: Not clear, but memory seems to be an issue, creating an array of pointers and sort that is out.
Constraints: O(n) space is not allowed. So you can not create a
pointer
to each object and sort them. O(log(n)) space is perfectly ok.
O(log(n)*m) is also allowed if that simplifies things.
My data has n >> m, i.e. n is much greater than m. "Ron Natalie" <ro*@sensor.com > wrote in message news:<3f******* *************** *@news.newshost ing.com>... "Jeff Schwab" <je******@comca st.net> wrote in message news:Wo******** ************@co mcast.com...
> Writing your own iterators would not be trivial, but probably would > be a educational. Having such iterators available would make your > data structure compatible with most of the standard library, and > might avoid countless future headaches.
The trouble with writing iterators for this problem is that he needs it to be variable size at run time and that the iterators have to be derferenceable and the derefenced types assignable. Add his requirement to not allocate even enough memory to hold pointers to each object, I can't figure out how you could do it. Thanks Ron, I think that is definitely a problem. But I still "think" it can be done, dont know how to thou...:)
I also think it can be done. However, it requires so much trickery that it is not interesting to do so. Any of the other options quickly become very appealing. My approach uses some dynamic memory, but probably less than an array of pointers would take. The actual amount depends on the number of copies std::sort makes internally, there is no way around this. I guess for a typical implementation this would be around log(n) copies, unless the implementation takes special care to dispose of temporaries. You cannot count on any of this though.
Hopefully, by the end of this thread, we'll have something simple
enough
to implement...:)
OK, how can we do it? Obviously every iterator must know the size of the object it is supposed to handle. The main problems we are facing:
- We cannot create real objects (directly), the size of the real object is only known at runtime. - std::sort is allowed to (and most frequently does) make extra copies of objects.
Asusmptions: - There are functions to copy these objects and to compare these objects. - The objects to be sorted don't need special construction or destruction and can be copied by the previously mentioned routine. They can be constructed by copying into a new memory area. - std::sort never uses pointers to objects, only iterators. I think the standard mandates this, but couldn't find it.
Would be interesting to know, what std::sort() is required to have
from
the standard. I think you are perfectly right that sort doesnt use
pointers
to the objects, only iterators and derefernces(*) the iterators...
We create a proxy class and let the iterator return proxy objects. These proxy objects store a pointer to some master descriptor that stores the location and size of the array and the size of the individual objects. We could store this in the proxy object itself, but that seems wasteful. Also, the proxy object stores a void* to store the data for the real object.
This proxy class is what our iterators value_type is.
Now the proxy object implements some intelligent constructors. I doubt we need a default constructor, the value type needs to be assignable only (this follows from the iterator requirements). So we create a constructor that is used only inside the iterator, it sets the data pointer to point inside the array at the correct location. If the copy constructor is called (which would be by std::sort) we dynamically allocate memory to hold the object and use the copying routine to fill it.
The assignment operator must use the copying routine if the destination is inside the array. If not, it can either use copy-construct-and-swap or the copying routine.
The destructor would check if the pointer points inside the array and if not deletes the object.
Obviously, we need to define an operator< for the proxy objects, this calls the comparison function above. If we template the proxy objects, we can use a functor for the comparison, potentially inlining the comaparison (this would be the only reason to use std::sort anyhow, so it makes sense).
Looking at the standard, this would fullfill all requirements for std::sort I could find. Somehow I think I did overlook something here, so scrutiny by others is appreciated. I also left obvious details out, obviously :-)
A note on exceptions. This would give the basic guarentee, if the copying and comparison routines give at least the basic guarentee.
A note on memory usage. Assuming that std::sort holds log(n) copies of objects internally, this aproach uses less memory than the sort-array-of-pointers aproach if log(n)*m < n*sizeof(void*) . So this greatly depends on these variables, but quickly holds for large n and gets less interesting for large m. Assume sizeof(void*)== 4, we get m < 4n/log(n). For n=100, m should be less than 60. For n=1000, m should be less than 400. These are gross approximations but should give you a feel.
Usually this is certainly the case for my data.
I hope anyone sees that you must have good reasons to do this. It is ugly, errorprone, prone to assumptions your implementation of std::sort makes (in this implementation &*it does not return a pointer to the real object, any pointer arithmetic will fail), difficult to maintain. There is no real reason why you should not call qsort in the first place, except as an accademic exercise.
First problem to qsort: It's slower than using sort()
Second problem to qsort: Later I might want to use other STL
algorithms on this data!
like for_each()? find()? ...?
Thanks a lot for your comments,
--Elijah
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]
On Sun, 04 Jan 2004 04:15:33 +0000, Elijah Bailey wrote:
[ csc++ removed, not relevant for what I want to say ] First problem to qsort: It's slower than using sort()
Qsort is slower only if std::sort can inline the comparison. In this case
this seems to me that with all the other overhead qsort will actually be
faster (let alone easier).
M4
Martijn Lievaart <m@remove.this. part.rtij.nl> wrote in message news:<pa******* *************** ******@remove.t his.part.rtij.n l>... On Sun, 04 Jan 2004 04:15:33 +0000, Elijah Bailey wrote:
[ csc++ removed, not relevant for what I want to say ]
First problem to qsort: It's slower than using sort()
Qsort is slower only if std::sort can inline the comparison. In this case this seems to me that with all the other overhead qsort will actually be faster (let alone easier).
M4
Yes, IF there is no 'simple' way to make std::sort() work.
And IF that is the case, then shouldnt there be another version
of std::sort() to do what I want to do. Doesnt it seem natural to
have an interface in c++ that does the same thing that the c
function qsort CAN do, without actually going the "c" way??
Thanks,
--Elijah
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]
Sounds like some sort of intermediate class is required in order to spoof a
RandomAccessIte rator as required by the STL sort() function.
i.e. you can create these to adapt the dynamic size of the elements to be
sorted to the static requirements of an iterator.
Though whether this is technically possible I'm not sure.
david m.
"Elijah Bailey" <ge******@hotma il.com> wrote in message
news:e0******** *************** ***@posting.goo gle.com... m@remove.this.p art.rtij.nl (Martijn Lievaart) wrote in message
news:<pa******* *************** ******@remove.t his.part.rtij.n l>... On Fri, 02 Jan 2004 03:13:26 -0800, Elijah Bailey wrote:
[ Please don't top post, thank you. M4 ]
[ Crossposted to csc++, is this standard complient? ]
[ Short description of the problem ]
We have an array of n*m bytes. It holds n objects of size m. Both are
only known at runtime. For some strange reason we want to sort this using std::sort. We know there are other solutions, the question is, can it be done using std::sort.
Thanks Martijn. This is a much better description than i came up with.
Constraints: Not clear, but memory seems to be an issue, creating an
array of pointers and sort that is out.
Constraints: O(n) space is not allowed. So you can not create a pointer to each object and sort them. O(log(n)) space is perfectly ok. O(log(n)*m) is also allowed if that simplifies things.
My data has n >> m, i.e. n is much greater than m.
"Ron Natalie" <ro*@sensor.com > wrote in message news:<3f******* *************** *@news.newshost ing.com>... > "Jeff Schwab" <je******@comca st.net> wrote in message > news:Wo******** ************@co mcast.com... > > > Writing your own iterators would not be trivial, but probably would > > be a educational. Having such iterators available would make your > > data structure compatible with most of the standard library, and > > might avoid countless future headaches. > > The trouble with writing iterators for this problem is that he needs
it> to be variable size at run time and that the iterators have to be > derferenceable and the derefenced types assignable. Add his > requirement to not allocate even enough memory to hold pointers to
each> object, I can't figure out how you could do it.
Thanks Ron, I think that is definitely a problem. But I still "think"
it can be done, dont know how to thou...:)
I also think it can be done. However, it requires so much trickery that
it is not interesting to do so. Any of the other options quickly become
very appealing. My approach uses some dynamic memory, but probably less than
an array of pointers would take. The actual amount depends on the number of copies std::sort makes internally, there is no way around this. I guess for a typical implementation this would be around log(n) copies, unless the implementation takes special care to dispose of temporaries. You cannot count on any of this though.
Hopefully, by the end of this thread, we'll have something simple enough to implement...:)
OK, how can we do it? Obviously every iterator must know the size of the object it is supposed to handle. The main problems we are facing:
- We cannot create real objects (directly), the size of the real object
is only known at runtime. - std::sort is allowed to (and most frequently does) make extra copies
of objects.
Asusmptions: - There are functions to copy these objects and to compare these
objects. - The objects to be sorted don't need special construction or
destruction and can be copied by the previously mentioned routine. They can be constructed by copying into a new memory area. - std::sort never uses pointers to objects, only iterators. I think the standard mandates this, but couldn't find it.
Would be interesting to know, what std::sort() is required to have from the standard. I think you are perfectly right that sort doesnt use pointers to the objects, only iterators and derefernces(*) the iterators...
We create a proxy class and let the iterator return proxy objects. These proxy objects store a pointer to some master descriptor that stores the location and size of the array and the size of the individual objects.
We could store this in the proxy object itself, but that seems wasteful. Also, the proxy object stores a void* to store the data for the real object.
This proxy class is what our iterators value_type is.
Now the proxy object implements some intelligent constructors. I doubt
we need a default constructor, the value type needs to be assignable only (this follows from the iterator requirements). So we create a
constructor that is used only inside the iterator, it sets the data pointer to point inside the array at the correct location. If the copy constructor is called (which would be by std::sort) we dynamically allocate memory to hold the object and use the copying routine to fill it.
The assignment operator must use the copying routine if the destination
is inside the array. If not, it can either use copy-construct-and-swap or
the copying routine.
The destructor would check if the pointer points inside the array and if not deletes the object.
Obviously, we need to define an operator< for the proxy objects, this calls the comparison function above. If we template the proxy objects,
we can use a functor for the comparison, potentially inlining the
comaparison (this would be the only reason to use std::sort anyhow, so it makes sense).
Looking at the standard, this would fullfill all requirements for std::sort I could find. Somehow I think I did overlook something here,
so scrutiny by others is appreciated. I also left obvious details out, obviously :-)
A note on exceptions. This would give the basic guarentee, if the
copying and comparison routines give at least the basic guarentee.
A note on memory usage. Assuming that std::sort holds log(n) copies of objects internally, this aproach uses less memory than the sort-array-of-pointers aproach if log(n)*m < n*sizeof(void*) . So this greatly depends on these variables, but quickly holds for large n and
gets less interesting for large m. Assume sizeof(void*)== 4, we get m < 4n/log(n). For n=100, m should be less than 60. For n=1000, m should be less than 400. These are gross approximations but should give you a
feel.
Usually this is certainly the case for my data.
I hope anyone sees that you must have good reasons to do this. It is
ugly, errorprone, prone to assumptions your implementation of std::sort makes (in this implementation &*it does not return a pointer to the real
object, any pointer arithmetic will fail), difficult to maintain. There is no
real reason why you should not call qsort in the first place, except as an accademic exercise.
First problem to qsort: It's slower than using sort() Second problem to qsort: Later I might want to use other STL algorithms on this data! like for_each()? find()? ...?
Thanks a lot for your comments, --Elijah
--- [ comp.std.c++ is moderated. To submit articles, try just posting with ] [ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ] [ --- Please see the FAQ before posting. --- ] [ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ] This thread has been closed and replies have been disabled. Please start a new discussion. Similar topics |
by: Lad |
last post by:
Hi,
I have a file of records of 4 fields each.
Each field is separated by a semicolon. That is
Filed1;Ffield2;Field3;Field4
But there may be also empty records such as
;;;;
(only semicolons).
|
by: SASRS |
last post by:
Here is my code. I am trying to see if I can put a
%@ LANGUAGE="VBSCRIPT" %>
<%
FieldA = Request.QueryString("A")
FieldB = Request.QueryString("B")
FieldC = Request.QueryString("C")
response.write("<TABLE ALIGN=CENTER>")
|
by: Mike |
last post by:
Hello,
I have a few rather urgent questions that I hope someone can help with (I
need to figure this out prior to a meeting tomorrow.) First, a bit of
background: The company I work for is developing a web-based application,
one part of which involves allowing the user the ability to page through
transaction "history" information.
The _summary_ history table will have the following fields: ServiceName,
Date, User-Ref1, User-Ref2,...
|
by: Todd |
last post by:
Hi. I want to sort the records on my form (using either a continuous form
or a
datasheet) by the unbound "description" column in a combo box on the form
(or in the datasheet.) Here's a rough text representation of what I'm
talking about
FORM
Item Number Description Category
(text box) (text box) (combo box - 2 columns)
|
by: Neil Hindry |
last post by:
I wonder if you can help me.
I have setup an address-book database in Access XP. I have the first name &
surname as separate fields. As I wanted to sort my database by surname and
then by first name I had surname before first name when I created the
fields of my database..
To do the sort (in table view) I highlighted the two columns (fields), in
this case surname and first name, and selected sort. Access then sorted the
database by...
| |
by: Matthew Curiale |
last post by:
I am creating an app that lists clients of a company for management of
different attributes for that company. The first page is a listing of
the companies currently in the database. I have my repeater working,
and paging/sorting works, but there is a small bug that I can't seem
to figure out.
If, for example, I display 5 records per page, the paging function
executes fine, and only shows 5 records per page. This is no problem.
When I...
|
by: SvenMathijssen |
last post by:
Hi,
I've been wrestling with a problem for some time that ought to be fairly simple, but turns out to be very difficult for me to solve. Maybe someone here knows the answer.
What I try to do is sort the records in a plain-text index file based on certain columns. The index file consists of records and fields within the records. The individual fields are separated by semicolons, the records by newlines. The index file is loaded into memory...
|
by: KevinADC |
last post by:
If you are entirely unfamiliar with using Perl to sort data, read the "Sorting Data with Perl - Part One and Two" articles before reading this article. Beginning Perl coders may find this article uses unfamiliar terms and syntax. Intermediate and advanced Perl coders should find this article useful. The object of the article is to inform the reader, it is not about how to code Perl or how to write good Perl code, but to teach the Schwartzian...
|
by: dorandoran |
last post by:
The sort on the childgrid is not working; nothing happens when I click on the each column header for sort. (I followed Satay's sample: http://www.codeproject.com/KB/aspnet/EditNestedGridView.aspx) and i am using object for datasource. please suggest.
= = = default.aspx = =
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"...
|
by: marktang |
last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However, people are often confused as to whether an ONU can Work As a Router. In this blog post, we’ll explore What is ONU, What Is Router, ONU & Router’s main usage, and What is the difference between ONU and Router. Let’s take a closer look !
Part I. Meaning of...
|
by: Hystou |
last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can effortlessly switch the default language on Windows 10 without reinstalling. I'll walk you through it.
First, let's disable language synchronization. With a Microsoft account, language settings sync across devices. To prevent any complications,...
| |
by: Oralloy |
last post by:
Hello folks,
I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>".
The problem is that using the GNU compilers, it seems that the internal comparison operator "<=>" tries to promote arguments from unsigned to signed.
This is as boiled down as I can make it.
Here is my compilation command:
g++-12 -std=c++20 -Wnarrowing bit_field.cpp
Here is the code in...
|
by: jinu1996 |
last post by:
In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven tapestry of website design and digital marketing. It's not merely about having a website; it's about crafting an immersive digital experience that captivates audiences and drives business growth.
The Art of Business Website Design
Your website is...
|
by: Hystou |
last post by:
Overview:
Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows Update option using the Control Panel or Settings app; it automatically checks for updates and installs any it finds, whether you like it or not. For most users, this new feature is actually very convenient. If you want to control the update process,...
|
by: agi2029 |
last post by:
Let's talk about the concept of autonomous AI software engineers and no-code agents. These AIs are designed to manage the entire lifecycle of a software development project—planning, coding, testing, and deployment—without human intervention. Imagine an AI that can take a project description, break it down, write the code, debug it, and then launch it, all on its own....
Now, this would greatly impact the work of software developers. The idea...
|
by: TSSRALBI |
last post by:
Hello
I'm a network technician in training and I need your help.
I am currently learning how to create and manage the different types of VPNs and I have a question about LAN-to-LAN VPNs.
The last exercise I practiced was to create a LAN-to-LAN VPN between two Pfsense firewalls, by using IPSEC protocols.
I succeeded, with both firewalls in the same network. But I'm wondering if it's possible to do the same thing, with 2 Pfsense firewalls...
|
by: adsilva |
last post by:
A Windows Forms form does not have the event Unload, like VB6. What one acts like?
| |
by: 6302768590 |
last post by:
Hai team
i want code for transfer the data from one system to another through IP address by using C# our system has to for every 5mins then we have to update the data what the data is updated we have to send another system
| |