← Back to branch summary

~zooko/cryptopp/trunk

« back to all changes in this revision

Viewing changes to simple.h

  • Committer: weidai
  • Date: 2004-09-03 10:57:31 UTC
  • Revision ID: svn-v4:57ff6487-cd31-0410-9ec3-f628ee90f5f0:trunk/c5:193
changes related to the next FIPS validation

Show diffs side-by-side

added added

removed removed

Lines of Context:
simple.h
24
24
class CRYPTOPP_NO_VTABLE AlgorithmImpl : public BASE
25
25
{
26
26
public:
27
 
        static std::string CRYPTOPP_API StaticAlgorithmName() {return ALGORITHM_INFO::StaticAlgorithmName();}
 
27
        static std::string StaticAlgorithmName() {return ALGORITHM_INFO::StaticAlgorithmName();}
28
28
        std::string AlgorithmName() const {return ALGORITHM_INFO::StaticAlgorithmName();}
29
29
};
30
30
 
32
32
class CRYPTOPP_DLL InvalidKeyLength : public InvalidArgument
33
33
{
34
34
public:
35
 
        explicit InvalidKeyLength(const std::string &algorithm, size_t length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid key length") {}
 
35
        explicit InvalidKeyLength(const std::string &algorithm, unsigned int length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid key length") {}
36
36
};
37
37
 
38
38
//! _
96
96
                {InputRejected() : NotImplemented("BufferedTransformation: this object doesn't allow input") {}};
97
97
 
98
98
        // shouldn't be calling these functions on this class
99
 
        size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
 
99
        unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking)
100
100
                {throw InputRejected();}
101
101
        bool IsolatedFlush(bool, bool) {return false;}
102
102
        bool IsolatedMessageSeriesEnd(bool) {throw InputRejected();}
103
103
 
104
 
        size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
 
104
        unsigned int ChannelPut2(const std::string &channel, const byte *begin, unsigned int length, int messageEnd, bool blocking)
105
105
                {throw InputRejected();}
106
106
        bool ChannelMessageSeriesEnd(const std::string &, int, bool) {throw InputRejected();}
107
107
};
137
137
                {return ChannelFlush(this->NULL_CHANNEL, hardFlush, propagation, blocking);}
138
138
        bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
139
139
                {return ChannelMessageSeriesEnd(this->NULL_CHANNEL, propagation, blocking);}
140
 
        byte * CreatePutSpace(size_t &size)
 
140
        byte * CreatePutSpace(unsigned int &size)
141
141
                {return ChannelCreatePutSpace(this->NULL_CHANNEL, size);}
142
 
        size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
 
142
        unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking)
143
143
                {return ChannelPut2(this->NULL_CHANNEL, begin, length, messageEnd, blocking);}
144
 
        size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
 
144
        unsigned int PutModifiable2(byte *inString, unsigned int length, int messageEnd, bool blocking)
145
145
                {return ChannelPutModifiable2(this->NULL_CHANNEL, inString, length, messageEnd, blocking);}
146
146
 
147
147
//      void ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1)
148
148
//              {PropagateMessageSeriesEnd(propagation, channel);}
149
 
        byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
 
149
        byte * ChannelCreatePutSpace(const std::string &channel, unsigned int &size)
150
150
                {size = 0; return NULL;}
151
 
        bool ChannelPutModifiable(const std::string &channel, byte *inString, size_t length)
 
151
        bool ChannelPutModifiable(const std::string &channel, byte *inString, unsigned int length)
152
152
                {this->ChannelPut(channel, inString, length); return false;}
153
153
 
154
 
        virtual size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking) =0;
155
 
        size_t ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking)
 
154
        virtual unsigned int ChannelPut2(const std::string &channel, const byte *begin, unsigned int length, int messageEnd, bool blocking) =0;
 
155
        unsigned int ChannelPutModifiable2(const std::string &channel, byte *begin, unsigned int length, int messageEnd, bool blocking)
156
156
                {return ChannelPut2(channel, begin, length, messageEnd, blocking);}
157
157
 
158
158
        virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true) =0;
210
210
        BufferedTransformation::CopyMessagesTo;
211
211
        BufferedTransformation::TransferAllTo;
212
212
        BufferedTransformation::CopyAllTo;
213
 
        size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=NULL_CHANNEL, bool blocking=true)
 
213
        unsigned int TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel=NULL_CHANNEL, bool blocking=true)
214
214
                {transferBytes = 0; return 0;}
215
 
        size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const
 
215
        unsigned int CopyRangeTo2(BufferedTransformation &target, unsigned long &begin, unsigned long end=ULONG_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const
216
216
                {return 0;}
217
217
};
218
218
 
221
221
public:
222
222
        std::string AlgorithmName() const {return "BitBucket";}
223
223
        void IsolatedInitialize(const NameValuePairs &parameters) {}
224
 
        size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
 
224
        unsigned int Put2(const byte *begin, unsigned int length, int messageEnd, bool blocking)
225
225
                {return 0;}
226
226
};
227
227