|
|
You are right, my reply was plainly wrong, because you cannot just wrap around with a text file.
With log files you may choose a different strategy: use multiple files, discarding the oldest one each time you need a new one.
If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.
This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke
[My articles]
|
|
|
|
|
Don't worry, some posters work better after their morning cappuccino.
|
|
|
|
|
|
dilara semerci wrote: have a size limit-say 50mb- and keep the newest data but erase the oldest not to exceed this size limit
Sure this is possible. If you want to keep log files under a certain size limit, the algorithm would be similar:
Write to end of log file. If it is over size X (e.g. 50MB), open a new file, seek log file 10% forward, copy the remaining log file, swap files (remove, rename), reopen new file. The reason why I suggested to skip 10% forward, is so that you don't have to to this operation every time. The application can fill the log file, it will be decreased in size from time to time, then it can fill it up again.
As an alternative to a single log file, use multiple files: Check if writing to end of log file will be over size X, if not write to end of file and if yes open a new file under a new name (overwrite if it exists) and continue logging there. The idea is to have multiple files to write to, e.g. logfile1.txt logfile2.txt logfile3.txt ... if you filled logfile3.txt you can start over with logfile1.txt again. Size of individual log file = total logging size X / number of files. Not very common, but possible.
Does this help?
/M
|
|
|
|
|
I am using a rich text control to display a block of formatted text. I create the control, set the content, then call the RequestResize method to notify the parent of the required height, and adjust the height to match. This works fine under VS 2005 on XP and Vista. Rebuilding under VS2010 as a 32 bit app and running on Windows 7 64 bit, the code does not work. The parent window does not receive the EN_REQUESTRESIZE message:
ON_NOTIFY(EN_REQUESTRESIZE, 0, OnRequestResize);
The parent window's OnRequestResize method is never called. So the control has zero height. This is bog standard code which worked fine before. Has anyone come across this? Any possible cause?
Okay: Problem solved. A zero control ID is not valid although we do not care about the control id, and it was accepted under VC 2005 on XP.
|
|
|
|
|
Hi everyone ! Does anybody work with CRectTracker on CScrollView ? Does actually work when scrolls is clicked ? I will appreciated any explanation , because I don't know the cause ... after scroll is modified , recttracker is mantain the old position !!!
|
|
|
|
|
You already asked this question here[^]; if somebody has an answer they will post it. Maybe you should check in your code where you repaint your view to make sure you are repositioning according to the scrollbar settings. I do not know the exact code as I have not used MFC for some time.
It's time for a new signature.
|
|
|
|
|
No need to ask the same question twice within a few hours. When someone wants / knows how to help, you will most likely get helped.
|
|
|
|
|
|
Hello Friends
I am creating a win32 based application using vs2008.Now I want to use boost library .I included the header files and lib files But after that when I compile it is giving error for zlib_compressor() Identifier not found.
Here are files that I included in my file:
#include <fstream>
#include <iostream>
#include <boost/iostreams/filtering_streambuf.hpp>
#include <boost/iostreams/copy.hpp>
#include <boost/iostreams/detail/config/zlib.hpp>
using namespace std;
using namespace boost;
using namespace boost::iostreams;
Any Ideas??
Thanks & Regards
Yogesh
|
|
|
|
|
It's declared in
#include <boost/iostreams/filter/zlib.hpp>
Edit: And nested within the boost::iostreams::zlib namespace.
|
|
|
|
|
Thanks For your reply. But Its not showing zlib in boost::iostream namespace.
Any Ideas?
Regards
Yogesh
|
|
|
|
|
yogeshs wrote: boost::iostream namespace
...and that's even with a trailing 's' in boost::iostreams?
|
|
|
|
|
Hello Nikalas
I am using iostreams.
and I am getting this error.
error C2039: 'zlib' : is not a member of 'boost::iostreams'
error C2871: 'zlib' : a namespace with this name does not exist
Is it possible that full package of boost library is not there?
Thanks For Ur Reply
Regards
Yogesh
|
|
|
|
|
yogeshs wrote: Is it possible that full package of boost library is not there?
That can of course be the case, but then you would get an error with
#include <boost/iostreams/filter/zlib.hpp>
Have you verified that you have that file? And if so have a look in it, and look at what namespace is used.
I revisited this file[^] and found that the namespace should be boost::iostreams. My bad.
But the zlib namespace should still be there, so there is probably something else missing for you.
|
|
|
|
|
Let me use example to describe what I need:
class Top
{
public:
virtual void something()=0;
int iType;
};
class SubA : public Top
{
public:
SubA() {iType=0;}
virtual void something(){}
};
class SubB : public Top
{
public:
SubB() {iType=1;}
virtual void something(){}
};
CArray<Top*,Top*> aryTop;
aryTop contains a set of pointers to SubA and/or SubB.
I need to cast Top* in the array to correct sub class, that is, an auto_cast() may return SubA* or SubB* by value of iType. auto_cast() may be macro, function or any idea.
i.e.
Top*p=aryTop.GetAt(0);
SubA*pa=auto_cast(p);
SubB*pb=auto_cast(p);
Do you have idea to do so?
|
|
|
|
|
The dynamic_cast operator works just like you want, and it doesn't need the iType member, because it rely on the RTTI:
Top* p = aryTop.GetAt(0);
SubA* pa = dynamic_cast<SubA *>(p); SubB* pb = dynamic_cast<SubB *>(p);
|
|
|
|
|
We call it dynamic_cast[^] operator.
If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.
This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke
[My articles]
|
|
|
|
|
It's easy to do, as others have said you can just use dynamic_cast, but should you really do it? Generally no. As soon as you start downcasting (with a few exceptions - pardon the pun) it's a sign that you've missed a virtual function somewhere. And as soon as you start missing virtual functions you're coupling your code more tightly than it needs to be - which usually ends up with ages compile times and people becoming scared of anything in an h file.
So if you've got a situation like...
I *p = <something set yonks ago>;
if( A *a = dynamic_cast<A *>( p ) )
{
a->do_a_specific_thing();
}
else if( B *b = dynamic_cast<B *>( p ) )
{
b->do_b_specific_thing();
}
think of modifying I instead so you end up with:
I *p = <something set yonks ago>;
p->do_specific_thing();
You make it easier to maintain (if you're maintaining the code you don't have to know about A and B) and extend (you can add another subclass without changing the client code). So if you're using dynamic_cast<> consider if you really need the client code to know about the concrete type of the objects it's operating on.
(And the same goes for type fields, they're even more useless and redundant than dynamic_cast).
Cheers,
Ash
Cheers,
Ash
|
|
|
|
|
...and if do_a_specific_thing and do_b_specific_thing have different signatures ?
|
|
|
|
|
If they do then that shows that your design is a bit bent and that perhaps A and B aren't related types at all and shouldn't be stored in the same collection. It's heading towards storing void pointers.
However if you have to do this (because you're using someone else's classes) that you can't modify then abstracting the operation and the original classes into independent hierarchies is the most general way to go. If you do that then you can still keep the clients from needing to know the exact classes and operations they're using. The only types that need to know the concrete types are the operation types but you end up paying the same sort of efficiency penalty you pay using dynamic_cast to do your dispatch.
Cheers,
Ash
|
|
|
|
|
Aescleal wrote: If they do then that shows that your design is a bit bent and that perhaps A and B aren't related types at all and shouldn't be stored in the same collection.
actually, it just shows that A and B use different input for some things. even the best design still has to deal with real life.
|
|
|
|
|
I'd have thought it would have shown that inheritance is not the correct thing to model "real life" in this case. If during processing of a collection you can't handle them in a uniform way then it's really dodgy gathering them up in the same place. If they haven't got a consistent interface to them then you're just asking for big headaches later.
In the "real world" (which is the place presumably programs deal with "real life") as soon as you start tacking on little lumps of interface on an ad-hoc basis you're opening the poor bugger that comes after you with a nightmare when he or she has to add a new concrete type that implements an interface. Not only have they got to implement the interface but they have to grub around in every client of the interface looking for the place where some form of dynamic_cast is happening and check there's no conversion there. If that's "real life" I'll stick with my ivory tower.
So if you really need to have something that processes two related classes in a different way, why not maintain a collection for each type? Something like:
std::vector<A> the_As;
std::vector<B> the_Bs;
You can then replace all the looping and dynamic_casting with:
std::for_each( the_As.begin(), the_As.end(), std::mem_fun( &A::do_something_A_related ) );
std::for_each( the_Bs.begin(), the_Bs.end(), std::mem_fun( &B::do_something_B_related ) );
replacing the final arguments with something that makes sense in either context (functors, bound functions taking different arguments)? Then it doesn't matter if A and B are related or not - you can process them independently or as a group. Admittedly you're still handling concrete types rather than interfaces but at least you're separating out the functionality rather than munging them together in one great melange. You can even have a collection for the interface pointers:
std::vector<I *> the_Is;
and not have to worry about deleting the objects pointed to as the other two collections handle that.
Another alternative is to say "A and B aren't related but share some characteristics I'd like to process similarly." You then implement A and B as concrete types without any inheritance relationship and THEN implement two bridges or adapters that implement I in terms of A and B.
Both these (rather stream of consciousnes) examples show that there's more ways to skin the feline than just saying "Oh sod it, dynamic_cast the difference." As I said before dynamic_casting or type switching is a sign that there's something cleaner inside waiting to get out.
Cheers,
Ash
|
|
|
|
|
Aescleal wrote: If during processing of a collection you can't handle them in a uniform way then it's really dodgy gathering them up in the same place.
you're thinking design-time. i'm thinking product-lifecycle-time.
if the design of v1.0 didn't anticipate everything v7.8 would be asked to do, you might end up with a collection of things which have deviated somewhat from the initial design. you might end up in a situation where objects of type A need a little extra attention because they've grown out of their training pants.
it happens.
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
![Java | [Coffee]](https://www.codeproject.com/script/Forums/Images/coffee.gif)
