#include <RioError.h>
Public Member Functions | |
| debugCerr () | |
| debugCerr & | operator<< (bool val) |
| debugCerr & | operator<< (short val) |
| debugCerr & | operator<< (unsigned short val) |
| debugCerr & | operator<< (int val) |
| debugCerr & | operator<< (unsigned int val) |
| debugCerr & | operator<< (long val) |
| debugCerr & | operator<< (unsigned long val) |
| debugCerr & | operator<< (long long int val) |
| debugCerr & | operator<< (unsigned long long int val) |
| debugCerr & | operator<< (float val) |
| debugCerr & | operator<< (double val) |
| debugCerr & | operator<< (long double val) |
| debugCerr & | operator<< (void *val) |
| debugCerr & | operator<< (streambuf *sb) |
| debugCerr & | operator<< (ostream &(*pf)(ostream &)) |
| debugCerr & | operator<< (ios &(*pf)(ios &)) |
| debugCerr & | operator<< (ios_base &(*pf)(ios_base &)) |
Definition at line 489 of file RioError.h.
| debugCerr::debugCerr | ( | ) |
Definition at line 772 of file RioError.cpp.
00773 { 00774 pthread_mutexattr_init( &err_mutex_attr ); 00775 pthread_mutexattr_settype( &err_mutex_attr, PTHREAD_MUTEX_RECURSIVE ); 00776 pthread_mutex_init( &err_mutex, &err_mutex_attr ); 00777 printHeader = true; 00778 }
| debugCerr & debugCerr::operator<< | ( | ios_base &(*)(ios_base &) | pf | ) |
Definition at line 1272 of file RioError.cpp.
| debugCerr & debugCerr::operator<< | ( | ios &(*)(ios &) | pf | ) |
Definition at line 1263 of file RioError.cpp.
| debugCerr & debugCerr::operator<< | ( | ostream &(*)(ostream &) | pf | ) |
Definition at line 1246 of file RioError.cpp.
01247 { 01248 pthread_mutex_lock( &err_mutex ); 01249 cerr << pf; 01250 if( ( !printHeader ) && 01251 ( pf == static_cast < std::ostream& ( * )( std::ostream& ) >( &std::endl ) 01252 ) ) 01253 { 01254 printHeader = true; 01255 pthread_mutex_unlock( &err_mutex ); // do endl 01256 } 01257 fflush( stderr ); 01258 pthread_mutex_unlock( &err_mutex ); // da funcao 01259 return *this; 01260 }
| debugCerr & debugCerr::operator<< | ( | streambuf * | sb | ) |
Definition at line 1216 of file RioError.cpp.
01217 { 01218 pthread_mutex_lock( &err_mutex ); 01219 01220 if( printHeader ) 01221 { 01222 void *trace[ 32 ]; 01223 char *myinfo; 01224 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01225 //come�a com tamanho 4, da� 01226 //subrai-se 3 aqui. 01227 01228 myinfo = myInfo(); 01229 cerr << myinfo; 01230 free( myinfo ); 01231 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01232 cerr << "[" << trace_size << "] " << sb; 01233 printHeader = false; 01234 } 01235 else 01236 { 01237 cerr << sb; 01238 pthread_mutex_unlock( &err_mutex ); 01239 } 01240 01241 return *this; 01242 }
| debugCerr & debugCerr::operator<< | ( | void * | val | ) |
Definition at line 1188 of file RioError.cpp.
01189 { 01190 pthread_mutex_lock( &err_mutex ); 01191 01192 if( printHeader ) 01193 { 01194 void *trace[ 32 ]; 01195 char *myinfo; 01196 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01197 //come�a com tamanho 4, da� 01198 //subrai-se 3 aqui. 01199 01200 myinfo = myInfo(); 01201 cerr << myinfo; 01202 free( myinfo ); 01203 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01204 cerr << "[" << trace_size << "] " << val; 01205 printHeader = false; 01206 } 01207 else 01208 { 01209 cerr << val; 01210 pthread_mutex_unlock( &err_mutex ); 01211 } 01212 01213 return *this; 01214 }
| debugCerr & debugCerr::operator<< | ( | long double | val | ) |
Definition at line 1160 of file RioError.cpp.
01161 { 01162 pthread_mutex_lock( &err_mutex ); 01163 01164 if( printHeader ) 01165 { 01166 void *trace[ 32 ]; 01167 char *myinfo; 01168 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01169 //come�a com tamanho 4, da� 01170 //subrai-se 3 aqui. 01171 01172 myinfo = myInfo(); 01173 cerr << myinfo; 01174 free( myinfo ); 01175 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01176 cerr << "[" << trace_size << "] " << val; 01177 printHeader = false; 01178 } 01179 else 01180 { 01181 cerr << val; 01182 pthread_mutex_unlock( &err_mutex ); 01183 } 01184 01185 return *this; 01186 }
| debugCerr & debugCerr::operator<< | ( | double | val | ) |
Definition at line 1132 of file RioError.cpp.
01133 { 01134 pthread_mutex_lock( &err_mutex ); 01135 01136 if( printHeader ) 01137 { 01138 void *trace[ 32 ]; 01139 char *myinfo; 01140 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01141 //come�a com tamanho 4, da� 01142 //subrai-se 3 aqui. 01143 01144 myinfo = myInfo(); 01145 cerr << myinfo; 01146 free( myinfo ); 01147 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01148 cerr << "[" << trace_size << "] " << val; 01149 printHeader = false; 01150 } 01151 else 01152 { 01153 cerr << val; 01154 pthread_mutex_unlock( &err_mutex ); 01155 } 01156 01157 return *this; 01158 }
| debugCerr & debugCerr::operator<< | ( | float | val | ) |
Definition at line 1104 of file RioError.cpp.
01105 { 01106 pthread_mutex_lock( &err_mutex ); 01107 01108 if( printHeader ) 01109 { 01110 void *trace[ 32 ]; 01111 char *myinfo; 01112 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01113 //come�a com tamanho 4, da� 01114 //subrai-se 3 aqui. 01115 01116 myinfo = myInfo(); 01117 cerr << myinfo; 01118 free( myinfo ); 01119 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01120 cerr << "[" << trace_size << "] " << val; 01121 printHeader = false; 01122 } 01123 else 01124 { 01125 cerr << val; 01126 pthread_mutex_unlock( &err_mutex ); 01127 } 01128 01129 return *this; 01130 }
| debugCerr & debugCerr::operator<< | ( | unsigned long long int | val | ) |
Definition at line 1076 of file RioError.cpp.
01077 { 01078 pthread_mutex_lock( &err_mutex ); 01079 01080 if( printHeader ) 01081 { 01082 void *trace[ 32 ]; 01083 char *myinfo; 01084 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01085 //come�a com tamanho 4, da� 01086 //subrai-se 3 aqui. 01087 01088 myinfo = myInfo(); 01089 cerr << myinfo; 01090 free( myinfo ); 01091 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01092 cerr << "[" << trace_size << "] " << val; 01093 printHeader = false; 01094 } 01095 else 01096 { 01097 cerr << val; 01098 pthread_mutex_unlock( &err_mutex ); 01099 } 01100 01101 return *this; 01102 }
| debugCerr & debugCerr::operator<< | ( | long long int | val | ) |
Definition at line 1048 of file RioError.cpp.
01049 { 01050 pthread_mutex_lock( &err_mutex ); 01051 01052 if( printHeader ) 01053 { 01054 void *trace[ 32 ]; 01055 char *myinfo; 01056 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01057 //come�a com tamanho 4, da� 01058 //subrai-se 3 aqui. 01059 01060 myinfo = myInfo(); 01061 cerr << myinfo; 01062 free( myinfo ); 01063 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01064 cerr << "[" << trace_size << "] " << val; 01065 printHeader = false; 01066 } 01067 else 01068 { 01069 cerr << val; 01070 pthread_mutex_unlock( &err_mutex ); 01071 } 01072 01073 return *this; 01074 }
| debugCerr & debugCerr::operator<< | ( | unsigned long | val | ) |
Definition at line 1020 of file RioError.cpp.
01021 { 01022 pthread_mutex_lock( &err_mutex ); 01023 01024 if( printHeader ) 01025 { 01026 void *trace[ 32 ]; 01027 char *myinfo; 01028 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01029 //come�a com tamanho 4, da� 01030 //subrai-se 3 aqui. 01031 01032 myinfo = myInfo(); 01033 cerr << myinfo; 01034 free( myinfo ); 01035 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01036 cerr << "[" << trace_size << "] " << val; 01037 printHeader = false; 01038 } 01039 else 01040 { 01041 cerr << val; 01042 pthread_mutex_unlock( &err_mutex ); 01043 } 01044 01045 return *this; 01046 }
| debugCerr & debugCerr::operator<< | ( | long | val | ) |
Definition at line 992 of file RioError.cpp.
00993 { 00994 pthread_mutex_lock( &err_mutex ); 00995 00996 if( printHeader ) 00997 { 00998 void *trace[ 32 ]; 00999 char *myinfo; 01000 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 01001 //come�a com tamanho 4, da� 01002 //subrai-se 3 aqui. 01003 01004 myinfo = myInfo(); 01005 cerr << myinfo; 01006 free( myinfo ); 01007 for( int j = trace_size; j > 0; j-- ) cerr << " "; 01008 cerr << "[" << trace_size << "] " << val; 01009 printHeader = false; 01010 } 01011 else 01012 { 01013 cerr << val; 01014 pthread_mutex_unlock( &err_mutex ); 01015 } 01016 01017 return *this; 01018 }
| debugCerr & debugCerr::operator<< | ( | unsigned int | val | ) |
Definition at line 964 of file RioError.cpp.
00965 { 00966 pthread_mutex_lock( &err_mutex ); 00967 00968 if( printHeader ) 00969 { 00970 void *trace[ 32 ]; 00971 char *myinfo; 00972 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 00973 //come�a com tamanho 4, da� 00974 //subrai-se 3 aqui. 00975 00976 myinfo = myInfo(); 00977 cerr << myinfo; 00978 free( myinfo ); 00979 for( int j = trace_size; j > 0; j-- ) cerr << " "; 00980 cerr << "[" << trace_size << "] " << val; 00981 printHeader = false; 00982 } 00983 else 00984 { 00985 cerr << val; 00986 pthread_mutex_unlock( &err_mutex ); 00987 } 00988 00989 return *this; 00990 }
| debugCerr & debugCerr::operator<< | ( | int | val | ) |
Definition at line 936 of file RioError.cpp.
00937 { 00938 pthread_mutex_lock( &err_mutex ); 00939 00940 if( printHeader ) 00941 { 00942 void *trace[ 32 ]; 00943 char *myinfo; 00944 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 00945 //come�a com tamanho 4, da� 00946 //subrai-se 3 aqui. 00947 00948 myinfo = myInfo(); 00949 cerr << myinfo; 00950 free( myinfo ); 00951 for( int j = trace_size; j > 0; j-- ) cerr << " "; 00952 cerr << "[" << trace_size << "] " << val; 00953 printHeader = false; 00954 } 00955 else 00956 { 00957 cerr << val; 00958 pthread_mutex_unlock( &err_mutex ); 00959 } 00960 00961 return *this; 00962 }
| debugCerr & debugCerr::operator<< | ( | unsigned short | val | ) |
Definition at line 908 of file RioError.cpp.
00909 { 00910 pthread_mutex_lock( &err_mutex ); 00911 00912 if( printHeader ) 00913 { 00914 void *trace[ 32 ]; 00915 char *myinfo; 00916 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 00917 //come�a com tamanho 4, da� 00918 //subrai-se 3 aqui. 00919 00920 myinfo = myInfo(); 00921 cerr << myinfo; 00922 free( myinfo ); 00923 for( int j = trace_size; j > 0; j-- ) cerr << " "; 00924 cerr << "[" << trace_size << "] " << val; 00925 printHeader = false; 00926 } 00927 else 00928 { 00929 cerr << val; 00930 pthread_mutex_unlock( &err_mutex ); 00931 } 00932 00933 return *this; 00934 }
| debugCerr & debugCerr::operator<< | ( | short | val | ) |
Definition at line 880 of file RioError.cpp.
00881 { 00882 pthread_mutex_lock( &err_mutex ); 00883 00884 if( printHeader ) 00885 { 00886 void *trace[ 32 ]; 00887 char *myinfo; 00888 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 00889 //come�a com tamanho 4, da� 00890 //subrai-se 3 aqui. 00891 00892 myinfo = myInfo(); 00893 cerr << myinfo; 00894 free( myinfo ); 00895 for( int j = trace_size; j > 0; j-- ) cerr << " "; 00896 cerr << "[" << trace_size << "] " << val; 00897 printHeader = false; 00898 } 00899 else 00900 { 00901 cerr << val; 00902 pthread_mutex_unlock( &err_mutex ); 00903 } 00904 00905 return *this; 00906 }
| debugCerr & debugCerr::operator<< | ( | bool | val | ) |
Definition at line 852 of file RioError.cpp.
00853 { 00854 pthread_mutex_lock( &err_mutex ); 00855 00856 if( printHeader ) 00857 { 00858 void *trace[ 32 ]; 00859 char *myinfo; 00860 int trace_size = backtrace( trace, 32 ) - 4; // Foi percebido que a pilha 00861 //come�a com tamanho 4, da� 00862 //subrai-se 3 aqui. 00863 00864 myinfo = myInfo(); 00865 cerr << myinfo; 00866 free( myinfo ); 00867 for( int j = trace_size; j > 0; j-- ) cerr << " "; 00868 cerr << "[" << trace_size << "] " << val; 00869 printHeader = false; 00870 } 00871 else 00872 { 00873 cerr << val; 00874 pthread_mutex_unlock( &err_mutex ); 00875 } 00876 00877 return *this; 00878 }
1.6.3