int JoinCommand :: Execute( ALib::CommandLine & cmd ) { Clear(); mKeep = cmd.HasFlag( FLAG_KEEP ); mOuterJoin = cmd.HasFlag( FLAG_OUTERJ ); mInvert = cmd.HasFlag( FLAG_INVERT ); mIgnoreCase = cmd.HasFlag( FLAG_ICASE ); if ( mOuterJoin && mInvert ) { CSVTHROW( "Cannot have both " << FLAG_OUTERJ << " and " << FLAG_INVERT << " flags" ); } string js = cmd.GetValue( FLAG_COLS ); BuildJoinSpecs( js ); IOManager io( cmd ); unsigned int scount = io.InStreamCount(); if ( scount < 2 ) { CSVTHROW( "Need at least two input streams" ); } BuildRowMap( io.CreateStreamParser( scount - 1 ) ); CSVRow row; for ( unsigned int i = 0; i < scount - 1; i++ ) { std::unique_ptr <ALib::CSVStreamParser> p( io.CreateStreamParser( i ) ); while( p->ParseNext( row ) ) { WriteJoinRows( io, row ); } } return 0; }
int TemplateCommand :: Execute( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); ReadTemplate( cmd ); if ( cmd.HasFlag( FLAG_FNAMES ) ) { mFileTemplate = cmd.GetValue( FLAG_FNAMES ); } IOManager io( cmd ); CSVRow row; while( io.ReadCSV( row ) ) { if ( Skip( row ) ) { continue; } if ( mFileTemplate.empty() ) { io.Out() << ReplaceColumns( mTemplate, row ); } else { FileOut( row ); } } return 0; }
int EditCommand :: Execute( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); for ( int i = 2; i < cmd.Argc(); i++ ) { if ( cmd.Argv( i ) == FLAG_EDIT ) { AddSubCmd( cmd.Argv( i + 1 ) ); i++; } } ALib::CommaList cl( cmd.GetValue( FLAG_COLS, "" ) ); CommaListToIndex( cl, mCols ); IOManager io( cmd ); CSVRow row; while( io.ReadCSV( row ) ) { if ( Skip( io, row ) ) { continue; } if ( ! Pass( io, row ) ) { EditRow( row ); } io.WriteRow( row ); } return 0; }
void FileSplitCommand :: ProcessFlags( ALib::CommandLine & cmd ) { mDir = cmd.GetValue( FLAG_FSDIR, DEF_DIR ); mFilePrefix = cmd.GetValue( FLAG_FSPRE, DEF_PREF ); mFileExt= cmd.GetValue( FLAG_FSEXT, DEF_EXT ); ALib::CommaList cl( cmd.GetValue( FLAG_COLS ) ); CommaListToIndex( cl, mColIndex ); mUseFieldNames = cmd.HasFlag( FLAG_USEFLD ); }
void DateFormatCommand :: ProcessFlags( ALib::CommandLine & cmd ) { ALib::CommaList cl( cmd.GetValue( FLAG_COLS, "" ) ); CommaListToIndex( cl, mFields ); string fmt = cmd.GetValue( FLAG_FMT, "" ); if ( ALib::IsEmpty( fmt ) ) { CSVTHROW( "Empty date format" ); } BuildFormat( fmt ); }
void AsciiTableCommand :: ProcessFlags( ALib::CommandLine & cmd ) { mUseLineSep = cmd.HasFlag( FLAG_SEP ); mHeadings = ALib::CommaList( cmd.GetValue( FLAG_HEADER, "" ) ); ALib::CommaList ra = ALib::CommaList( cmd.GetValue( FLAG_RALIGN, "" ) ); CommaListToIndex( ra, mRightAlign ); if ( mHeadings.Size() && mHeadings.At(0) != FILE_HEADER) { CSVRow r; for ( unsigned int i = 0; i < mHeadings.Size() ; i++ ) { r.push_back( mHeadings.At( i ) ); } AddRow( r ); } }
int EvalCommand :: Execute( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); IOManager io( cmd ); CSVRow row; mDiscardInput = cmd.HasFlag( FLAG_DISCARD ); GetExpressions( cmd ); while( io.ReadCSV( row ) ) { if ( Skip( io, row ) ) { continue; } if ( ! Pass( io, row ) ) { SetParams( row, io ); if ( mDiscardInput ) { row.clear(); } Evaluate( row ); } io.WriteRow( row ); } return 0; }
int DSVReadCommand :: Execute( ALib::CommandLine & cmd ) { ReadFlags( cmd ); mIsCSV = cmd.HasFlag( FLAG_CSV ); mCollapseSep = cmd.HasFlag( FLAG_CMULTI ); IOManager io( cmd ); CSVRow row; string line; while( io.ReadLine( line ) ) { ParseDSV( line, row ); io.WriteRow( row ); } return 0; }
void FixedCommand :: BuildFields( const ALib::CommandLine & cmd ) { mFields.clear(); ALib::CommaList cl( cmd.GetValue( FLAG_COLS ) ); // chop into pairs if ( cl.Size() == 0 ) { CSVTHROW( "Need fields specified with " << FLAG_COLS << " flag" ); } for ( unsigned int i = 0; i < cl.Size(); i++ ) { vector <string> tmp; if ( ALib::Split( cl.At(i), ':', tmp ) != 2 ) { CSVTHROW( "Invalid field specification: " << cl.At(i) ); } if ( ! ALib::IsInteger( tmp[0] ) || ! ALib::IsInteger( tmp[1] ) ) { CSVTHROW( "Invalid field specification: " << cl.At(i) ); } unsigned int f1 = ALib::ToInteger( tmp[0] ); unsigned int f2 = ALib::ToInteger( tmp[1] ); if ( f1 == 0 || f2 == 0 ) { CSVTHROW( "Invalid field specification: " << cl.At(i) ); } mFields.push_back( std::make_pair( f1, f2 ) ); } }
void CallCommand :: ProcessFlags( const ALib::CommandLine & cmd ) { string bs = cmd.GetValue( FLAG_BSIZE, ALib::Str( DEF_OUTBUF_SIZE ) ); if ( ! ALib::IsInteger( bs )) { CSVTHROW( "Value for buffer size must be integer" ); } mOutBufSize = ALib::ToInteger( bs ) * 1024; if ( mOutBufSize < DEF_OUTBUF_SIZE ) { CSVTHROW( "Output buffer size too small" ); } mDLL = cmd.GetValue( FLAG_DLL ); mFuncName = cmd.GetValue( FLAG_FUNC ); ALib::CommaList cl( cmd.GetValue( FLAG_COLS ) ); CommaListToIndex( cl, mFields ); }
void SQLCommand :: BuildCols( const ALib::CommandLine & cmd, const string & flag, SQLColSpec::Vec & cols ) { bool havenames = false; cols.clear(); if ( cmd.FlagCount( flag ) > 1 ) { CSVTHROW( "Need fields specified by single " << flag << " flag" ); } ALib::CommaList cl( cmd.GetValue( flag ) ); for ( unsigned int i = 0; i < cl.Size(); i++ ) { vector <string> tmp; if ( ALib::Split( cl.At(i), ':', tmp ) > 2 ) { CSVTHROW( "Invalid column specification: " << cl.At(i) ); } if ( tmp.size() == 0 ) { CSVTHROW( "Empty column specification" ); } if ( ! ALib::IsInteger( tmp[0] ) ) { CSVTHROW( "Field index must be integer in " << cl.At(i) ); } int icol = ALib::ToInteger( tmp[0] ); if ( icol <= 0 ) { CSVTHROW( "Field index must be greater than xero in " << cl.At(i) ); } if ( tmp.size() == 1 && havenames ) { CSVTHROW( "Must specify all column names" ); } havenames = havenames || tmp.size() == 2; string colname = tmp.size() == 2 ? tmp[1] : string(""); cols.push_back( SQLColSpec( icol - 1, colname ) ); } }
int TrimCommand :: Execute( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); if ( cmd.HasFlag( FLAG_TRLEAD ) || cmd.HasFlag( FLAG_TRTRAIL ) ) { mTrimLead = cmd.HasFlag( FLAG_TRLEAD ); mTrimTrail = cmd.HasFlag( FLAG_TRTRAIL ); } else { mTrimLead = mTrimTrail = true; } if ( cmd.HasFlag( FLAG_WIDTH ) ) { GetWidths( cmd.GetValue( FLAG_WIDTH ) ); } ALib::CommaList cl( cmd.GetValue( FLAG_COLS, "" ) ); CommaListToIndex( cl, mFields ); IOManager io( cmd ); CSVRow row; while( io.ReadCSV( row ) ) { if ( Skip( row ) ) { continue; } if ( ! Pass( row ) ) { Trim( row ); } io.WriteRow( row ); } return 0; }
void SQLCommand :: GetCommonValues( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); mTable = cmd.GetValue( FLAG_TABLE ); if ( mTable == "" ) { CSVTHROW( "Need table name specified by " << FLAG_TABLE << " flag" ); } if ( ! cmd.HasFlag( FLAG_SQLSEP ) ) { mSep ="\n;\n"; } else { mSep = ALib::UnEscape( cmd.GetValue( FLAG_SQLSEP ) ); } string noq = cmd.GetValue( FLAG_NOQUOTE, "" ); if ( ! ALib::IsEmpty( noq ) ) { CommaListToIndex( ALib::CommaList( noq ), mNoQuote ); } mQuoteNulls = cmd.HasFlag( FLAG_QNULLS ); mEmptyNulls = cmd.HasFlag( FLAG_ENULLS ); }
static unsigned int GetField( const ALib::CommandLine & cmd, const string & option ) { string rc = cmd.GetValue( option ); if ( ! ALib::IsInteger( rc ) ) { CSVTHROW( "Value for " << option << " must be integer" ); } int n = ALib::ToInteger( rc ); if ( n <= 0 ) { CSVTHROW( "Value for " << option << " must be greater than zero" ); } return (unsigned int) n - 1; }
void DateReadCommand :: ProcessFlags( ALib::CommandLine & cmd ) { ALib::CommaList cl( cmd.GetValue( FLAG_COLS, "" ) ); CommaListToIndex( cl, mFields ); string mask = cmd.GetValue( FLAG_MASK, "" ); string cys = cmd.GetValue( FLAG_CDATE, ALib::Str( BASE_YEAR ) ); NotBoth( cmd, FLAG_BDLIST, FLAG_BDEXCL ); if ( cmd.HasFlag( FLAG_BDLIST ) ) { mWriteAction = WriteBad; } else if ( cmd.HasFlag( FLAG_BDEXCL ) ) { mWriteAction = WriteGood; } else { mWriteAction = WriteAll; } if ( ! ALib::IsInteger( cys )) { CSVTHROW( "Invalid year value " << cys ); } int cy = ALib::ToInteger( cys ); string mnames = cmd.GetValue( FLAG_MNAMES, MONTH_NAMES ); delete mReader; mReader = new MaskedDateReader( mask, mnames, cy ); }
int TruncPadBase :: Execute( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); string ps = cmd.GetValue( FLAG_PAD ); ALib::CommaList padding( ps ); unsigned int ncols = padding.Size(); bool ncolspec = false; // use explicit size or not if ( ncols == 0 || cmd.HasFlag( FLAG_NUM ) ) { if ( ! cmd.HasFlag( FLAG_NUM ) ) { CSVTHROW( "Need -n flag to specify field count" ); } ncolspec = true; string nv = cmd.GetValue( FLAG_NUM ); if ( ALib::ToInteger( nv, "-n flag needs integer value" ) < 0 ) { CSVTHROW( FLAG_NUM << " needs value greater or equal to zero" ); } ncols = ALib::ToInteger( nv ); } IOManager io( cmd ); CSVRow row; while( io.ReadCSV( row ) ) { if ( Skip( io, row ) ) { continue; } if ( ! Pass( io, row ) ) { unsigned int nc = ncolspec ? ncols : row.size() + padding.Size(); ProcessRow( row, nc, padding ); } io.WriteRow( row ); } return 0; }
int FileInfoCommand :: Execute( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); mTwoCols = cmd.HasFlag( FLAG_TWOC ); mBasename = cmd.HasFlag( FLAG_BASEN ); IOManager io( cmd ); CSVRow row; while( io.ReadCSV( row ) ) { if ( Skip( io, row ) ) { continue; } if ( Pass( io, row ) ) { io.WriteRow( row ); continue; } string fname = mBasename ? ALib::Filename( io.CurrentFileName() ).Base() : io.CurrentFileName(); CSVRow outrow; if ( mTwoCols ) { outrow.push_back( fname ); outrow.push_back( ALib::Str( io.CurrentLine() )); } else { outrow.push_back( fname + " (" + ALib::Str( io.CurrentLine() ) + ")" ); } ALib::operator+=( outrow, row ); io.WriteRow( outrow ); } return 0; }
void ShuffleCommand :: ProcessFlags( const ALib::CommandLine & cmd ) { string sn = cmd.GetValue( FLAG_NUM, ALib::Str(INT_MAX -1) ); if ( ! ALib::IsInteger( sn )) { CSVTHROW( "Value for " << FLAG_NUM << " must be integeer" ); } if ( ALib::ToInteger( sn ) < 0 ) { CSVTHROW( "Value for " << FLAG_NUM << " must be zero or greater" ); } mCount = ALib::ToInteger( sn ); string sr = cmd.GetValue( FLAG_RSEED, "-1" ); if ( ! ALib::IsInteger( sr ) ) { CSVTHROW( "Value for " << FLAG_RSEED << " must be integer" ); } int n = ALib::ToInteger( sr ); mSeed = n < 0 ? std::time(0) : n; if ( cmd.HasFlag( FLAG_COLS ) ) { ALib::CommaList cl( cmd.GetValue( FLAG_COLS ) ); CommaListToIndex( cl, mFields ); } }
void ExcludeCommand :: ProcessFlags( const ALib::CommandLine & cmd ) { NotBoth( cmd, FLAG_REVCOLS, FLAG_COLS, ReqOp::Required ); string es = cmd.GetValue( FLAG_IF, "" ); if ( es != "" ) { string emsg = mExpr.Compile( es ); if ( emsg != "" ) { CSVTHROW( emsg + " " + es ); } } mReverse = cmd.HasFlag( FLAG_REVCOLS ); string sn = cmd.GetValue( FLAG_COLS, "" ); if ( sn == "" ) { sn = cmd.GetValue( FLAG_REVCOLS, "" ); } CommaListToIndex( ALib::CommaList( sn ), mFields ); if ( mFields.size() == 0 ) { CSVTHROW( "Field list specified by " << FLAG_COLS << " or " << FLAG_REVCOLS << " cannot be empty" ); } }
void ValidateCommand :: GetOutputMode( const ALib::CommandLine & cl ) { string om = cl.GetValue( FLAG_OMODE, "report" ); if ( om == "report" ) { mOutMode = Reports; } else if ( om == "pass" ) { mOutMode = Passes; } else if ( om == "fail" ) { mOutMode = Fails; } else { CSVTHROW( "Invalid value for " << FLAG_OMODE << ": " << om ); } }
void DSVBase :: ReadFlags( const ALib::CommandLine & cl ) { string delim = cl.GetValue( FLAG_SEP, ALib::Str( DEF_DELIM ) ); if ( delim.size() == 0 ) { CSVTHROW( "Separator specified by " << FLAG_SEP << " cannot be empty" ); } else if ( delim.size() == 1 ) { mDelim = delim[0]; } else if ( delim.size() == 2 && delim[0] == '\\' ) { if ( delim[1] == 't' ) { mDelim = '\t'; } else { CSVTHROW( "Bad escaped separator specified by " << FLAG_SEP ); } } else { CSVTHROW( "Bad separator specified by " << FLAG_SEP ); } string fields = cl.GetValue( FLAG_COLS, "" ); CommaListToIndex( ALib::CommaList( fields ), mFields ); }
void SummaryCommand :: ProcessFlags( const ALib::CommandLine & cmd ) { int nf = CountNonGeneric( cmd ); if ( nf == 0 ) { CSVTHROW( "Need a summary flag" ); } else if ( nf != 1 ) { CSVTHROW( "Only one summary flag allowed" ); } if ( cmd.HasFlag( FLAG_AVG ) ) { mType = Average; GetFields( cmd, FLAG_AVG ); } else if ( cmd.HasFlag( FLAG_MIN ) ) { mType = Min; GetFields( cmd, FLAG_MIN ); } else if ( cmd.HasFlag( FLAG_MAX ) ) { mType = Max; GetFields( cmd, FLAG_MAX ); } else if ( cmd.HasFlag( FLAG_FREQ ) ) { mType = Frequency; GetFields( cmd, FLAG_FREQ ); } else if ( cmd.HasFlag( FLAG_MEDIAN ) ) { mType = Median; GetFields( cmd, FLAG_MEDIAN); } else if ( cmd.HasFlag( FLAG_MODE) ) { mType = Mode; GetFields( cmd, FLAG_MODE ); } else if ( cmd.HasFlag( FLAG_SUM ) ) { mType = Sum; GetFields( cmd, FLAG_SUM ); } else if ( cmd.HasFlag( FLAG_SIZE ) ) { mType = Size; } else { CSVTHROW( "Should never happen in SummaryCommand::ProcessFlags" ); } }
PivotCommand::Action GetAction( const ALib::CommandLine & cmd ) { string as = cmd.GetValue( FLAG_ACTION ); if ( as == OP_SUM ) { return PivotCommand::Action::Sum; } else if ( as == OP_COUNT ) { return PivotCommand::Action::Count; } else if ( as == OP_AVG ) { return PivotCommand::Action::Average; } else { CSVTHROW( "Invalid value for " << FLAG_ACTION << ". Need one of sum, count, avg" ); } }
int ReadFixedCommand :: Execute( ALib::CommandLine & cmd ) { mTrim = ! cmd.HasFlag( FLAG_KEEP ); BuildFields( cmd ); IOManager io( cmd ); string line; CSVRow row; while( io.ReadLine( line ) ) { MakeRow( line, row ); io.WriteRow( row ); } return 0; }
int ValidateCommand :: Execute( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); GetOutputMode( cmd ); ReadValidationFile( cmd ); IOManager io( cmd ); CSVRow row; // we optionally return an error code to the shell if validation failed int errtotal = 0; bool errcode = cmd.HasFlag( FLAG_ERRCODE ); while( io.ReadCSV( row ) ) { if ( Skip( io, row ) ) { continue; } int errcount = 0; for ( unsigned int i = 0; i < mRules.size(); i++ ) { ValidationRule::Results res = mRules[i]->Apply( row ); if ( res.size() && mOutMode == Reports ) { Report( io, res, errcount ); errcount++; errtotal += errcount; continue; } if ( res.size() ) { errcount++; if ( mOutMode == Fails ) { io.WriteRow( row ); break; } } } if ( mOutMode == Passes && errcount == 0 ) { io.WriteRow( row ); } errtotal += errcount; } // exit code of 2 indicates program detected invalid data return errtotal && errcode ? 2 : 0; }
void RemoveNewlineCommand :: ProcessFlags( const ALib::CommandLine & cmd ) { string scols = cmd.GetValue( FLAG_COLS, "" ); ALib::CommaList cl( cmd.GetValue( FLAG_COLS, "" ) ); CommaListToIndex( cl, mFields); if ( cmd.HasFlag( FLAG_EXCLNL ) && cmd.HasFlag( FLAG_STR ) ) { CSVTHROW( "Flags " << FLAG_EXCLNL << " and " << FLAG_STR << " are mutually exclusive" ); } mSep = cmd.GetValue( FLAG_STR, "" ); ExpandSep(); mExcludeAfter = cmd.HasFlag( FLAG_EXCLNL ); }
void TemplateCommand :: ReadTemplate( const ALib::CommandLine & cmd ) { string fname = cmd.GetValue( FLAG_TFILE ); if ( ALib::IsEmpty( fname ) ) { CSVTHROW( "Need template file name specified with " << FLAG_TFILE << " flag" ); } std::ifstream ifs( fname.c_str() ); if ( ! ifs.is_open() ) { CSVTHROW( "Cannot open file " << fname << " for input" ); } mTemplate = ""; string line; while( std::getline( ifs, line ) ) { mTemplate += line + "\n"; } ifs.close(); }
int WriteFixedCommand :: Execute( ALib::CommandLine & cmd ) { GetSkipOptions( cmd ); BuildFields( cmd ); IOManager io( cmd ); if ( cmd.HasFlag( FLAG_RULER ) ) { io.Out() << Ruler() << "\n"; } CSVRow row; while( io.ReadCSV( row ) ) { if ( Skip( row ) ) { continue; } string line = MakeFixedOutput( row ); io.Out() << line << "\n"; } return 0; }
void ValidateCommand :: ReadValidationFile( const ALib::CommandLine & cmd ) { Clear(); string fname = cmd.GetValue( FLAG_VFILE ); if ( fname == "" ) { CSVTHROW( "Need validation file specified by " << FLAG_VFILE << " flag" ); } std::ifstream ifs( fname.c_str() ); if ( ! ifs.is_open() ) { CSVTHROW( "Cannot open validation file " << fname << " for input" ); } string line; while( std::getline( ifs, line ) ) { if ( ALib::IsEmpty( line ) || line[0] == '#' ) { // a comment continue; } unsigned int pos = 0; string name = ReadName( line, pos ); FieldList flist = ReadFields( line, pos ); ValidationRule::Params params = ReadParams( line, pos ); ValidationRule * rule = RuleFactory::CreateRule( name, flist, params ); if ( rule == 0 ) { CSVTHROW( "Unknown rule: " << name ); } //rule->DumpOn( std::cout ); mRules.push_back( rule ); } }
void SummaryCommand :: GetFields( const ALib::CommandLine & cmd, const std::string & flag ) { ALib::CommaList cl( cmd.GetValue( flag ) ); CommaListToIndex( cl, mFields ); }