SCStreamException.h

Go to the documentation of this file.

//
//  SCStreamException.h
//  scl
//
//  Created by Viacheslav Smolensky on 03.03.12.
//  Copyright (c) 2007 - 2018 by Samond Development Corporation. All rights reserved.
//

#import <Foundation/Foundation.h>
#import <scl/SCException.h>
#import <scl/SCFileStream.h>

#pragma mark -
#pragma mark Class Constants

#define SCStreamExceptionClass          @"SCStreamException"

#define SCStreamErrorName               @"SCStream"


#pragma mark -
#pragma mark Error ID Constants

#define SCStreamEIDUnspecified          @"SCL-20020"

#define SCStreamEIDNotOpen              @"SCL-20021"

#define SCStreamEIDReadOnly             @"SCL-20022"

#define SCStreamEIDWriteOnly            @"SCL-20023"

#define SCStreamEIDUnknown              @"SCL-20024"

#define SCStreamEIDUnexpected           @"SCL-20025"

#define SCStreamEIDUnsupported          @"SCL-20026"

#define SCStreamEIDIncompleteReading    @"SCL-20027"

#define SCStreamEIDIncompleteWriting    @"SCL-20028"

#define SCStreamEIDOpening              @"SCL-20029"

#define SCStreamEIDRead                 @"SCL-20030"

#define SCStreamEIDWrite                @"SCL-20031"

#define SCStreamEIDNumber               @"SCL-20032"

#define SCStreamEIDOpenMode             @"SCL-20033"

#define SCStreamEIDEmptyPath            @"SCL-20034"

#define SCStreamEIDEOF                  @"SCL-20035"

#define SCStreamEIDOffset               @"SCL-20036"

#define SCStreamEIDOffsetWhence         @"SCL-20037"


#pragma mark -
#pragma mark Class Support Types

typedef enum {
    SCStreamErrorUnspecified        = -20020,
    
    SCStreamErrorNotOpen            = -20021,

    SCStreamErrorReadOnly           = -20022,
    
    SCStreamErrorWriteOnly          = -20023,
    
    SCStreamErrorUnknown            = -20024,

    SCStreamErrorUnexpected         = -20025,
    
    SCStreamErrorUnsupported        = -20026,
    
    SCStreamErrorIncompleteReading  = -20027,
    
    SCStreamErrorIncompleteWriting  = -20028,
    
    SCStreamErrorOpening            = -20029,
    
    SCStreamErrorRead               = -20030,

    SCStreamErrorWrite              = -20031,
    
    SCStreamErrorNumber             = -20032,

    SCStreamErrorOpenMode           = -20033,
    
    SCStreamErrorEmptyPath          = -20034,
    
    SCStreamErrorEOF                = -20035,
    
    SCStreamErrorOffset             = -20036,
    
    SCStreamErrorOffsetWhence       = -20037,

} SCStreamErrorCode;

typedef SCInteger SCStreamError;


@interface SCStreamException : SCException {
    NSString                *_streamName;   // Erroneous stream name
    NSString                *_unknown;      // Unknown class name
    NSString                *_unexpected;   // Unexpected class name
    NSString                *_expected;     // Expected class name
    NSString                *_unsupported;  // Unsupported class name
    SCSize                   _readedBytes;  // Number of the readed characters
    SCSize                   _writedBytes;  // Number of the writed characters
    SCSize                   _waitedBytes;  // Number of the waited characters
    SCInteger                _openError;    // Stream open error code
    SCInteger                _readError;    // Reading error code
    SCInteger                _writeError;   // Writing error code
    NSString                *_numberType;   // Unsupported NSNumber type code
    SCFileStreamOpenMode     _openMode;     // Incorrect file stream opening mode
    SCSystemError            _seekError;    // File stream seeking system error code
    NSInteger                _offset;       // Incorrect file stream offset
    SCFileStreamOffsetWhence _whence;       // Incorrect file stream offset whence
}

#pragma mark -
#pragma mark Instance Properties

@property (nonatomic, readonly, retain) NSString *streamName;

@property (nonatomic, readonly, retain) NSString *unknown;

@property (nonatomic, readonly, retain) NSString *unexpected;

@property (nonatomic, readonly, retain) NSString *expected;

@property (nonatomic, readonly, retain) NSString *unsupported;

@property (nonatomic, readonly, assign) SCSize readedBytes;

@property (nonatomic, readonly, assign) SCSize writedBytes;

@property (nonatomic, readonly, assign) SCSize waitedBytes;

@property (nonatomic, readonly, assign) SCInteger openError;

@property (nonatomic, readonly, assign) SCInteger readError;

@property (nonatomic, readonly, assign) SCInteger writeError;

@property (nonatomic, readonly, retain) NSString *numberType;

@property (nonatomic, readonly, assign) SCFileStreamOpenMode openMode;

@property (nonatomic, readonly, assign) SCSystemError seekError;

@property (nonatomic, readonly, assign) NSInteger offset;

@property (nonatomic, readonly, assign) SCFileStreamOffsetWhence whence;

#pragma mark -
#pragma mark Creating and Initializing the Generic Stream Exceptions (SCL-20020)
+ (instancetype)exceptionWithStream:(NSString *)stream
                             reason:(NSString *)reason
                               code:(SCInteger)code
                                eid:(NSString *)eid;
+ (instancetype)exceptionWithReason:(NSString *)reason code:(SCInteger)code eid:(NSString *)eid;
+ (instancetype)exceptionWithStream:(NSString *)stream;
+ (instancetype)exception;
- (instancetype)initWithStream:(NSString *)stream reason:(NSString *)reason code:(SCInteger)code eid:(NSString *)eid;
- (instancetype)initWithReason:(NSString *)reason code:(SCInteger)code eid:(NSString *)eid;

#pragma mark -
#pragma mark Creating Not Open Stream Exception (SCL-20021)
+ (instancetype)exceptionWithNotOpenStream:(NSString *)stream;
+ (instancetype)exceptionWithNotOpen;

#pragma mark -
#pragma mark Creating Read Only Stream Exception (SCL-20022)
+ (instancetype)exceptionWithReadOnlyStream:(NSString *)stream;
+ (instancetype)exceptionWithReadOnly;

#pragma mark -
#pragma mark Creating Write Only Stream Exception (SCL-20023)
+ (instancetype)exceptionWithWriteOnlyStream:(NSString *)stream;
+ (instancetype)exceptionWithWriteOnly;

#pragma mark -
#pragma mark Creating Unknown Class Exception (SCL-20024)
+ (instancetype)exceptionWithUnknown:(NSString *)name stream:(NSString *)stream;
+ (instancetype)exceptionWithUnknown:(NSString *)name;

#pragma mark -
#pragma mark Creating Unexpected Class Exception (SCL-20025)
+ (instancetype)exceptionWithUnexpected:(NSString *)unexpected expected:(NSString *)expected stream:(NSString *)stream;
+ (instancetype)exceptionWithUnexpected:(NSString *)unexpected expected:(NSString *)expected;

#pragma mark -
#pragma mark Creating Unsupported Class Exception (SCL-20026)
+ (instancetype)exceptionWithUnsupported:(NSString *)name stream:(NSString *)stream;
+ (instancetype)exceptionWithUnsupported:(NSString *)name;

#pragma mark -
#pragma mark Creating Incompleted Operation Exception (SCL-20027 and SCL-20028)
+ (instancetype)exceptionWithReaded:(SCSize)readed waited:(SCSize)waited stream:(NSString *)stream;
+ (instancetype)exceptionWithReaded:(SCSize)readed waited:(SCSize)waited;
+ (instancetype)exceptionWithWrited:(SCSize)writed waited:(SCSize)waited stream:(NSString *)stream;
+ (instancetype)exceptionWithWrited:(SCSize)writed waited:(SCSize)waited;

#pragma mark -
#pragma mark Creating Opening Exception (SCL-20029)
+ (instancetype)exceptionWithOpenError:(SCInteger)error stream:(NSString *)stream;
+ (instancetype)exceptionWithOpenError:(SCInteger)error;

#pragma mark -
#pragma mark Creating Reading Exception (SCL-20030)
+ (instancetype)exceptionWithReadError:(SCInteger)error stream:(NSString *)stream;
+ (instancetype)exceptionWithReadError:(SCInteger)error;

#pragma mark -
#pragma mark Creating Writing Exception (SCL-20031)
+ (instancetype)exceptionWithWriteError:(SCInteger)error stream:(NSString *)stream;
+ (instancetype)exceptionWithWriteError:(SCInteger)error;

#pragma mark -
#pragma mark Creating Number Object Exception (SCL-20032)
+ (instancetype)exceptionWithUnsupportedNumberType:(NSString *)type stream:(NSString *)stream;
+ (instancetype)exceptionWithUnsupportedNumberType:(NSString *)type;

#pragma mark -
#pragma mark Creating Incorrect Open Mode Exception (SCL-20033)
+ (instancetype)exceptionWithOpenMode:(SCFileStreamOpenMode)mode path:(NSString *)path;
+ (instancetype)exceptionWithOpenMode:(SCFileStreamOpenMode)mode;

#pragma mark -
#pragma mark Creating Empty Path Exception (SCL-20034)
+ (instancetype)exceptionWithEmptyPath;

#pragma mark -
#pragma mark Creating End of Stream Exception (SCL-20035)
+ (instancetype)exceptionWithEndOfFile:(NSString *)file;
+ (instancetype)exceptionWithEndOfFile;

#pragma mark -
#pragma mark Creating Offset Exception (SCL-20036 and SCL-20037)
+ (instancetype)exceptionWithSeekError:(SCSystemError)error
                                whence:(SCFileStreamOffsetWhence)whence
                                offset:(NSInteger)offset
                                  path:(NSString *)path;
+ (instancetype)exceptionWithSeekError:(SCSystemError)error
                                whence:(SCFileStreamOffsetWhence)whence
                                offset:(NSInteger)offset;
+ (instancetype)exceptionWithSeekError:(SCSystemError)error path:(NSString *)path;
+ (instancetype)exceptionWithSeekError:(SCSystemError)error;
+ (instancetype)exceptionWithWhence:(SCFileStreamOffsetWhence)whence path:(NSString *)path;
+ (instancetype)exceptionWithWhence:(SCFileStreamOffsetWhence)whence;

@end