Example #1
0
	void SettingsFile::ProcessVariable(const std::string& line, const std::string& file_name, const unsigned int& line_number)
	{
		ASSERT(line.length() >= 2);
		// Looks for an equals sign ('=') on this line.
		const unsigned int separator = line.find_first_of('=');
		// Get the raw variable name.
		std::string name = line.substr(0, separator);
		// Make sure that the variable name is valid.
		CheckVariableName(name, file_name, line_number);
		// If this variable name already exists, then this is a bad variable name.
		if(integer_variables.find(name) != integer_variables.end() || string_variables.find(name) != string_variables.end())
		{
			throw SettingsFile::SyntaxError(SettingsFile::SyntaxError::BAD_VARIABLE_NAME, file_name, line_number);
		}
		// This check prevents an std::out_of_range exception. If the separator is the last character
		// on this line, then the variable's value is malformed.
		if(separator == line.length() - 1)
		{
			throw SettingsFile::SyntaxError(SettingsFile::SyntaxError::BAD_VALUE, file_name, line_number);
		}
		// Get the raw variable value.
		std::string value = line.substr(separator + 1, line.npos);
		// Make sure that the variable value is valid.
		CheckVariableValue(value, file_name, line_number);
		// Add the variable name/pair to the map of settings.
		long integer_value = 0;
		if(IsIntegerValue(value, integer_value) == true)
		{
			// The value is an integer.
			integer_variables.insert(std::make_pair(name, integer_value));
		}
		else
		{
			// The value is a string.
			string_variables.insert(std::make_pair(name, value));
		}
	}
Example #2
0
void processModify(const std::string& line, int num, IptcData &iptcData)
{
    std::string::size_type keyStart = line.find_first_not_of(" \t", 1);
    std::string::size_type keyEnd = line.find_first_of(" \t", keyStart+1);
    std::string::size_type dataStart = line.find_first_not_of(" \t", keyEnd+1);

    if (keyStart == std::string::npos ||
        keyEnd == std::string::npos ||
        dataStart == std::string::npos) {
        std::ostringstream os;
        os << "Invalid \'m\' command at line " << num;
        throw Error(1, os.str());
    }

    std::string key(line.substr(keyStart, keyEnd-keyStart));
    IptcKey iptcKey(key);

    std::string data(line.substr(dataStart));
    // if data starts and ends with quotes, remove them
    if (data.at(0) == '\"' && data.at(data.size()-1) == '\"') {
        data = data.substr(1, data.size()-2);
    }
    TypeId type = IptcDataSets::dataSetType(iptcKey.tag(), iptcKey.record());
    Value::AutoPtr value = Value::create(type);
    value->read(data);

    IptcData::iterator iter = iptcData.findKey(iptcKey);
    if (iter != iptcData.end()) {
        iter->setValue(value.get());
    }
    else {
        int rc = iptcData.add(iptcKey, value.get());
        if (rc) {
            throw Error(1, "Iptc dataset already exists and is not repeatable");
        }
    }
}
std::string Client::connect(const std::string& httpURL)
{
  auto colpos = httpURL.find_first_of("://");
  if (colpos < 4 || colpos > 5)
    return std::string();

  if(nullptr == ctx)
    {
      ctx = std::make_shared<ClientCtx>();
    }
  ctx->scheme.fill(0x00);
  ::memcpy(ctx->scheme.data(), httpURL.data(), colpos);

  for(unsigned c = 0; c < 5; ++c)
    ctx->scheme[c] = std::tolower(ctx->scheme[c]);

  ctx->host_and_port = ExtractHostPortHttp(httpURL);
  ctx->port = ctx->isHttps() ? 443 : 80;

  auto pos = ctx->host_and_port.find_first_of(':');
  if (std::string::npos != pos)
    {//case format host.com:443
      char* end = nullptr;
      ctx->port = ::strtol(ctx->host_and_port.data() + (1 + pos), &end, 10);
      std::array<char, 80> hostStr;
      hostStr.fill(0x00);
      ::memcpy(hostStr.data(), ctx->host_and_port.data(), pos);
    }
  else
    {//case format  host.com (no port)
      std::array<char,8> temp; temp.fill(0);
      ::snprintf(temp.data(), temp.size(), ":%u", ctx->port);
      ctx->host_and_port.append(temp.data());
    }

  return ctx->host_and_port;
}
Example #4
0
void 
xAnim::setFrames(std::string frames)
{
  vecFrame.clear();

  std::string tmp;


  int f;
  int i;
  int num;
  int e;

  num = frames.length();
      
  for (i = 0; i < num; i++)
  {
    if (frames[i] == ' ') { continue; }
    f = frames.find_first_of(',', i);
    
    if (f == -1) { f = num; } 
  
    tmp = frames.substr(i, f - i);

    //remove spaces from end
      e = tmp.find_first_of(' ', 0);
      tmp = tmp.substr(0, e);


    //printf("Found frame: [%s] \n", tmp.c_str() );
    vecFrame.push_back(tmp);

    i = f;        
     
  }//nexti 

}//setframes
Example #5
0
bool WideVM::loadAsmProgram(std::string programcode, std::string * error)
{
    const std::size_t atmark = programcode.find_first_of('@');
    if(atmark == std::string::npos)
    {
        if(error)
            (*error) = "no @ char (separator of header and code) found";

        return false;
    }

    stripCppComments(programcode);

    if(!bakeHeader(programcode.substr(0, atmark + 1u), m_globalnames, m_globals, m_channelnames, m_prognames, error))
    {
        return false;
    }

    m_particlesize = m_channelnames.size();

    if(!assemble(programcode.substr(atmark + 1u), m_program, error))
    {
        return false;
    }

    findSubprograms(); //check if we have any sub progs?

    if(m_subprograms.empty())
    {
        if(error)
            (*error) = "there are no subprograms in this program";

        return false;
    }

    return true;
}
Example #6
0
std::string CConsoleHistory::NextLine(const std::string& current)
{
    GML_STDMUTEX_LOCK(hist);

    std::string prefix, message;
    if ((current.find_first_of("aAsS") == 0) && (current[1] == ':')) {
        prefix  = current.substr(0, 2);
        message = current.substr(2);
    } else {
        message = current;
    }

    if (pos == lines.end()) {
        AddLineRaw(message);
        pos = lines.end();
        return prefix;
    }

    if (*pos != message) {
        if (pos != --lines.end()) {
            AddLineRaw(message);
        } else {
            if (AddLineRaw(message)) {
                pos = lines.end();
                return prefix;
            }
        }
    }

    pos++;

    if (pos == lines.end()) {
        return prefix;
    }

    return prefix + *pos;
}
/*--------------------------------------------------------------------------
FUNCTION NAME: AnalyseCmdBuf
DESCRIPTION: 解析出字符串中的port chanel chanelStatus
AUTHOR:王鑫堂 
PARAMETERS: IN recvStr, INOUT port, INOUT chanel, INOUT chanelStatus 
            例如输入com1 chanel1 ON, port=1, chanel=1, chanelStatus=1
RETURN: 
*-------------------------------------------------------------------------*/
bool AnalyseCmdBuf(std::string recvStr, int & port, int & chanel, int & chanelStatus)
{
	EraseMultiSpace(recvStr);

	int posFirst = recvStr.find_first_of(" ");
	std::string dataStr1 = recvStr.substr(0, posFirst);
	port = getDigit(dataStr1);
	if (port < 1 || port >16)
	{
		return false;
	}

	int posLast = recvStr.find_last_of(" ");
	dataStr1 = recvStr.substr(posFirst+1, posLast-posFirst-1);
	chanel = getDigit(dataStr1);
	if (chanel < 1 || chanel >16)
	{
		return false;
	}

	dataStr1 = recvStr.substr(posLast+1, std::string::npos-posLast-1);
	transform(dataStr1.begin(), dataStr1.end(), dataStr1.begin(), ::tolower);
	if (!dataStr1.compare("on"))
	{
		chanelStatus = 1;
	}
	else if (!dataStr1.compare("off"))
	{
		chanelStatus = 0;
	}
	else
	{
		return false;
	}

	return true;
}
Example #8
0
void CAESinkFactory::ParseDevice(std::string &device, std::string &driver)
{
  int pos = device.find_first_of(':');
  if (pos > 0)
  {
    driver = device.substr(0, pos);
    std::transform(driver.begin(), driver.end(), driver.begin(), ::toupper);

    // check that it is a valid driver name
    if (
#if defined(TARGET_ANDROID)
        driver == "AUDIOTRACK"  ||
#elif defined(TARGET_RASPBERRY_PI)
        driver == "PI"          ||
        driver == "ALSA"        ||
#elif defined(TARGET_DARWIN_IOS)
        driver == "DARWINIOS"  ||
#elif defined(TARGET_DARWIN_OSX)
        driver == "DARWINOSX"  ||
#elif defined(TARGET_LINUX) || defined(TARGET_FREEBSD)
  #if defined(HAS_ALSA)
        driver == "ALSA"        ||
  #endif
  #if defined(HAS_PULSEAUDIO)
        driver == "PULSE"       ||
  #endif
        driver == "OSS"         ||
#endif
        driver == "PROFILER"    ||
        driver == "NULL")
      device = device.substr(pos + 1, device.length() - pos - 1);
    else
      driver.clear();
  }
  else
    driver.clear();
}
Example #9
0
// pResource may be changed on return, and it could be NULL if the function returns false.
bool CResourceManager::ParseResourcePathInput ( std::string strInput, CResource* &pResource, std::string &strPath, std::string &strMetaPath )
{
    ReplaceOccurrencesInString ( strInput, "\\", "/" );
    eAccessType accessType = ACCESS_PUBLIC;

    if ( strInput[0] == '@' )
    {
        accessType = ACCESS_PRIVATE;
        strInput = strInput.substr ( 1 );
    }

    if ( strInput[0] == ':' )
    {
        unsigned int iEnd = strInput.find_first_of("/");
        if ( iEnd )
        {
            std::string strResourceName = strInput.substr(1,iEnd-1);
            pResource = g_pClientGame->GetResourceManager()->GetResource ( strResourceName.c_str() );
            if ( pResource && strInput[iEnd+1] )
            {
                strMetaPath = strInput.substr(iEnd+1);
                if ( IsValidFilePath ( strMetaPath.c_str() ) )
                {
                    strPath = pResource->GetResourceDirectoryPath ( accessType, strMetaPath );
                    return true;
                }
            }
        }
    }
    else if ( pResource && IsValidFilePath ( strInput.c_str() ) )
    {
        strPath = pResource->GetResourceDirectoryPath ( accessType, strInput );
        strMetaPath = strInput;
        return true;
    }
    return false;
}
Example #10
0
void Option::process(const std::string& option, std::string& arg) const
{
	std::string::size_type pos = option.find_first_of(":=");
	std::string::size_type len = pos == std::string::npos ? option.length() : pos;
	if (icompare(option, 0, len, _fullName, 0, len) == 0)
	{
		if (takesArgument())
		{
			if (argumentRequired() && pos == std::string::npos)
				throw MissingArgumentException(_fullName + " requires " + argumentName());
			if (pos != std::string::npos)
				arg.assign(option, pos + 1, option.length() - pos - 1);
			else
				arg.clear();
		}
		else if (pos != std::string::npos)
		{
			throw UnexpectedArgumentException(option);
		}
		else arg.clear();
	}
	else if (!_shortName.empty() && option.compare(0, _shortName.length(), _shortName) == 0)
	{
		if (takesArgument())
		{
			if (argumentRequired() && option.length() == _shortName.length())
				throw MissingArgumentException(_shortName + " requires " + argumentName());
			arg.assign(option, _shortName.length(), option.length() - _shortName.length());
		}
		else if (option.length() != _shortName.length())
		{
			throw UnexpectedArgumentException(option);
		}
		else arg.clear();
	}
	else throw UnknownOptionException(option);
}
Example #11
0
void PUBLIC scatterArgs(const std::string buffer,
                        std::vector<std::string> &args, std::vector<char *> &argv)
{
  std::string separators = " \t\n\r";
  args.clear();
  argv.clear();
  size_t first = 0;
  size_t last = 0;
  for(;;) {
    first = buffer.find_first_not_of(separators, last);
    if (first == std::string::npos) {
      return;
    }
    last = buffer.find_first_of(separators, first);
    if (last == std::string::npos) {
      args.push_back(buffer.substr(first));
      argv.push_back(const_cast<char *>(args.back().c_str()));
      return;
    } else {
      args.push_back(buffer.substr(first, last - first));
      argv.push_back(const_cast<char *>(args.back().c_str()));
    }
  }
}
Example #12
0
int CSQLItem::analyzeData(const std::string& strLine)
{
	int					nFunRes = 0;
	std::string::size_type nFindTmp = std::string::npos;

	if (strLine.empty())
	{
		nFunRes = -1;
		return nFunRes;
	}				   

	nFindTmp = strLine.find_first_of("=");
	if (std::string::npos == nFindTmp)
	{
		nFunRes = -1;
		return nFunRes;
	}
	m_strSqlId = strLine.substr(0, nFindTmp);
	m_strSqlLine = strLine.substr(nFindTmp + 1);
			
	CUtilityFun::getInstance().trim(m_strSqlId);
				 
	return nFunRes;
}
/* Splits the input line from the user to tokens. */
void twitClient::splitLine(std::string& line,std::vector<std::string>& tokens) const
{
    std::string::size_type pos1,pos2;
    std::string token;
    while (line.size() > 0)
    {
        pos1 = line.find_first_not_of(SPACE, 0);
        if (pos1 == std::string::npos)
        {
            break;
        }
        pos2 = line.find_first_of(SPACE, pos1);
        if (pos2 == std::string::npos)
        {
            pos2 = line.size();
        }
        token = line.substr(0,pos2);
        if (tokens.size() == 0)
        {
        	token.erase(std::remove_if(token.begin(), token.end(), isspace), token.end());
        }
        if (tokens.size() == 1)
        {
        	if (upperCopy(tokens.at(0)) != TWIT)
        	{
        		token.erase(std::remove_if(token.begin(), token.end(), isspace), token.end());
        	}
        	else
        	{
        		token = token.substr(1,token.size() - 1);
        	}
        }
        tokens.push_back(token);
        line = line.substr(pos2,line.size() - pos2);
    }
}
Example #14
0
//-------------------------------------------------------------------------------------
WatcherObject::WatcherObject(std::string path):
  path_(path),
  name_(),
  strval_(),
  id_(0),
  s_(),
  numWitness_(0)
{
	std::string::size_type fi = path.find_first_of('/');
	if(fi == std::string::npos)
	{
		name_ = path;
		path_ = "";
	}
	else
	{
		std::vector<std::string> vec;
		KBEngine::strutil::kbe_split(path, '/', vec);

		std::vector<std::string>::size_type size = vec.size();
		name_ = vec[size - 1];
		path_ = path.erase(path.size() - name_.size() - 1, path.size());
	}
}
Example #15
0
std::vector<std::string> split_simple( std::string str, std::string sep, int max )
{
  str = strip( str, sep );

  std::string::size_type start = 0, last = 0;
  int count = 0;

  std::vector<std::string> sl;

  while( true )
    {
      if( max > 0 )
	count++;

      if( count >= max && max > 0 )
	{
	  sl.push_back( str.substr( last ) );
	  break;
	}


      start = str.find_first_of( sep, last );

      if( start == std::string::npos )
	{
	  sl.push_back( str.substr( last ) );
	  break;
	}

      sl.push_back( str.substr( last, start - last ) );

      last = start + 1;
    }

  return sl;
}
Example #16
0
File: os.hpp Project: benh/minotaur
inline Try<void> mkdir(const std::string& directory)
{
  const std::vector<std::string>& tokens = strings::split(directory, "/");

  std::string path = "";

  // We got an absolute path, so keep the leading slash.
  if (directory.find_first_of("/") == 0) {
    path = "/";
  }

  std::vector<std::string>::const_iterator iterator = tokens.begin();
  while (iterator != tokens.end()) {
    const std::string& token = *iterator;
    path += token;
    if (::mkdir(path.c_str(), 0755) < 0 && errno != EEXIST) {
      return Try<void>::error("mkdir: %s: %s", path.c_str(), strerror(errno));
    }
    path += "/";
    ++iterator;
  }

  return Try<void>::value();
}
Example #17
0
void Parser::parseMsz(const std::string &cmd)
{
    glm::vec2 pos;
    size_t rank = cmd.find_first_of(' ');
    
    if (rank == std::string::npos) {
        _map->setSize(glm::vec2(1, 1));
        throw FormatException();
    }
    pos.x = getNbFromString(cmd);
    pos.y = getNbFromString(cmd.substr(rank + 1));
    _map->setSize(pos);
    if (_map->size()) {
        for (Map::iterator it = _map->begin(); it != _map->end();) {
            it = _map->erase(it);
        }
        for (Map::Players::iterator it = _map->playerBegin(); it != _map->playerEnd();) {
            it = _map->removePlayer(it);
        }
        for (Map::Eggs::iterator it = _map->eggBegin(); it != _map->eggEnd();) {
            it = _map->removeEgg(it);
        }
    }
}
Example #18
0
//******************************************************************************
bool AttrTextToBinaryBlob::attrFileIsAttrLine(
    const std::string & i_line,
    std::string & o_attrString)
{
    /*
     * e.g. "target = k0:n0:s0:centaur.mba:pall:call" - false
     *      "ATTR_MSS_DIMM_MFG_ID_CODE[0][0] u32[2][2] 0x12345678" - true
     */
    bool l_isAttrLine = false;

    if (0 == i_line.find(ATTR_FILE_ATTR_START_STR))
    {
        // The attribute ID string terminates with either '[' or ' '
        size_t l_pos = i_line.find_first_of("[ ");

        if (l_pos != std::string::npos)
        {
            o_attrString = i_line.substr(0, l_pos);
            l_isAttrLine = true;
        }
    }

    return l_isAttrLine;
}
Example #19
0
DotOsgWrapper::DotOsgWrapper(osg::Object* proto,
              const std::string& name,
              const std::string& associates,
              ReadFunc readFunc,
              WriteFunc writeFunc,
              ReadWriteMode readWriteMode)
{


    _prototype = proto;
    _name = name;


    // copy the names in the space delimited associates input into
    // a vector of separated names.
    std::string::size_type start_of_name = associates.find_first_not_of(' ');
    while (start_of_name!=std::string::npos)
    {
        std::string::size_type end_of_name = associates.find_first_of(' ',start_of_name);
        if (end_of_name!=std::string::npos)
        {
            _associates.push_back(std::string(associates,start_of_name,end_of_name-start_of_name));
            start_of_name = associates.find_first_not_of(' ',end_of_name);
        }
        else
        {
            _associates.push_back(std::string(associates,start_of_name,associates.size()-start_of_name));
            start_of_name = end_of_name;
        }
    }

    _readFunc = readFunc;
    _writeFunc = writeFunc;

    _readWriteMode = readWriteMode;
}
Example #20
0
bool PlayerRelationsManager::checkName(const std::string &name)
{
    const size_t size = name.size();
    const std::string check = config.getStringValue("unsecureChars");
    const std::string lastChar = name.substr(size - 1, 1);

    if (name.substr(0, 1) == " " || lastChar == " " || lastChar == "."
        || name.find("  ") != std::string::npos)
    {
        return false;
    }
    else if (check.empty())
    {
        return true;
    }
    else if (name.find_first_of(check) != std::string::npos)
    {
        return false;
    }
    else
    {
        return true;
    }
}
Example #21
0
File: utils.C Project: hoa84/sight
// Given a string and a line width returns a variant of the string where line breaks are inserted
// at approximately every lineWidth characters.
std::string wrapStr(std::string str, unsigned int lineWidth) {
  string multiLineStr = "";
  unsigned int i=0;
  while(i<str.length()-lineWidth) {
    // Look for the next line-break
    unsigned int nextLB = str.find_first_of("\n", i);
    // If the next line is shorter than lineWidth, add it to labelMulLineStr and move on to the next line
    if(nextLB-i < lineWidth) {
      multiLineStr += str.substr(i, nextLB-i+1);
      i = nextLB+1;
    // If the next line is longer than lineWidth, add just lineWidth characters to labelMulLineStr
    } else {
      // If it is not much longer than lineWidth, don't break it up
      if(i>=str.length()-lineWidth*1.25) break;
      multiLineStr += str.substr(i, lineWidth) + "\\n";
      i += lineWidth;
    }
  }
  // Add the last line in str to labelMulLineStr
  if(i<str.length())
    multiLineStr += str.substr(i, str.length()-i);
  
  return multiLineStr;
}
std::string TWFunc::Remove_Trailing_Slashes(const std::string& path, bool leaveLast)
{
	std::string res;
	size_t last_idx = 0, idx = 0;

	while(last_idx != std::string::npos)
	{
		if(last_idx != 0)
			res += '/';

		idx = path.find_first_of('/', last_idx);
		if(idx == std::string::npos) {
			res += path.substr(last_idx, idx);
			break;
		}

		res += path.substr(last_idx, idx-last_idx);
		last_idx = path.find_first_not_of('/', idx);
	}

	if(leaveLast)
		res += '/';
	return res;
}
Example #23
0
void CDemoRecorder::SetName(const std::string& mapname)
{
	struct tm *newtime;
	__time64_t long_time;
	_time64(&long_time);                /* Get time as long integer. */
	newtime = _localtime64(&long_time); /* Convert to local time. */

	char buf[500];
	sprintf(buf,"%02i%02i%02i",newtime->tm_year%100,newtime->tm_mon+1,newtime->tm_mday);
	std::string name=std::string(buf)+"-"+mapname.substr(0,mapname.find_first_of("."));
	name+=std::string("-")+VERSION_STRING;
	
	sprintf(buf,"demos/%s.sdf",name.c_str());
	CFileHandler ifs(buf);
	if(ifs.FileExists()){
		for(int a=0;a<9999;++a){
			sprintf(buf,"demos/%s-%i.sdf",name.c_str(),a);
			CFileHandler ifs(buf);
			if(!ifs.FileExists())
				break;
		}
	}
	wantedName = buf;
}
Example #24
0
			std::vector<unsigned long> DLCchecking::splitVersion(std::string vstr)
			{
				std::vector<unsigned long> sv;
				std::string delimiters = ".";
				size_t current;
				size_t next = -1;
				do
				{
					current = next + 1;
					next = vstr.find_first_of(delimiters, current);
					std::cout << vstr.substr(current, next - current) << std::endl;
					unsigned long tmp = 0;
					try
					{
						tmp = ToolBox::stoul(vstr.substr(current, next - current));
					}
					catch (std::out_of_range oor)
					{
						tmp = LONG_MAX;
					}
					sv.push_back(tmp);
				} while (next != std::string::npos);
				return sv;
			}
Example #25
0
    void locale_data::parse_from_country(std::string const &locale_name) 
    {
        size_t end = locale_name.find_first_of("@.");
        std::string tmp = locale_name.substr(0,end);
        if(tmp.empty())
            return;
        for(unsigned i=0;i<tmp.size();i++) {
            if('a' <= tmp[i] && tmp[i]<='a')
                tmp[i]=tmp[i]-'a'+'A';
            else if(tmp[i] < 'A' && 'Z' < tmp[i])
                return;
        }

        country = tmp;

        if(end >= locale_name.size())
            return;
        else if(locale_name[end] == '.') {
           parse_from_encoding(locale_name.substr(end+1));
        }
        else if(locale_name[end] == '@') {
           parse_from_variant(locale_name.substr(end+1));
        }
    }
Example #26
0
/** 
 * Append a single token to the given list of tokens.
 * The token is assumed to be lowercase, free of comments, and non-blank.  
 * This function is for handling shortcut
 * syntax, e.g. 1 4r, which should translate into four copies of the token 1
 */
void appendToTokenList( const std::string& token, token_list_t& tokens ){
  if( token.find_first_of("123456789") == 0 && token.at(token.length()-1) == 'r' ){
    // token starts with a number and ends with r: treat as repeat syntax.
    const char* string = token.c_str();
    char* p;
    int num = strtol( string, &p, 10 );
    if( (p - string) != static_cast<int>(token.length()) - 1 ){
      // oops, this isn't repeat format after all
      tokens.push_back(token);
      return;
    }

    if( OPT_DEBUG ) { std::cout << "Repeat syntax: " << token << " repeats " 
                                << tokens.back() << " " << num << " times." << std::endl; }

    for( int i = 0; i < num; ++i){
      const std::string& last_tok = tokens.back();
      tokens.push_back( last_tok );
    }
  }
  else{
    tokens.push_back(token);
  }
}
int RodsConnection::getFile(const std::string &localPath, const std::string &objPath, bool verifyChecksum,
                            bool allowOverwrite, unsigned int numThreads)
{
    int status = 0;
    dataObjInp_t getParam;

    // sanity check, input argument string must be nonempty and begin with /
    if (objPath.empty() || objPath.find_first_of('/') != 0)
        return (-1);

    this->mutexLock();

    // zero rods api param struct
    memset(&getParam, 0, sizeof (dataObjInp_t));

    // set parameters for get operation
    getParam.oprType = GET_OPR;
    getParam.numThreads = numThreads;

    if (verifyChecksum)
        addKeyVal(&getParam.condInput, VERIFY_CHKSUM_KW, "");

    if (allowOverwrite)
        addKeyVal(&getParam.condInput, FORCE_FLAG_KW, "");

    // copy obj path string
    rstrcpy(getParam.objPath, objPath.c_str(), MAX_NAME_LEN);

    // execute data object get
    status = rcDataObjGet(this->rodsCommPtr, &getParam, (char*)localPath.c_str());

    this->mutexUnlock();

    // return rods api status
    return (status);
}
Example #28
0
int ParseDate(Date *pdate,std::string str,std::map<int,int>& month_days)
{
    int err = 0;
    size_t pos2;
    size_t pos1;
    do {
        pos1 = str.find_first_of('-');
        pos2 = str.find_last_of('-');
        std::string year = str.substr(0,pos1);
        debug_log(year);
        std::string month = str.substr(pos1+1,pos2-pos1-1);
        debug_log(month);
        std::string day = str.substr(pos2+1);
        debug_log(day);

        /**
         *检查是否为正确的格式的字符串
         * */
        err = CheckInput(year,month,day);
        if ( 0 != err ) {   
            std::cerr<<"Check Input error!"<<std::endl;
            break;
        }
        /**
         *将数据写入到Date结构中
         * */
        err = pdate->GetData(year,month,day,month_days);
        if ( 0 != err ) {
            std::cerr<<"Date->GetData error!"<<std::endl;
            break;
        }
    
    } while(0);

    return err;
}
Example #29
0
//-------------------------------------------------------------------------------------
bool WatcherPaths::addWatcher(std::string path, WatcherObject* pwo)
{
	std::string szpath, name;
	std::string::size_type fi = path.find_first_of('/');
	if(fi == std::string::npos)
	{
		name = path;
		szpath = "";
	}
	else
	{
		std::vector<std::string> vec;
		KBEngine::strutil::kbe_split(path, '/', vec);

		std::vector<std::string>::size_type size = vec.size();
		name = vec[size - 1];
		szpath = path.erase(path.size() - name.size() - 1, path.size());
	}

	static WATCHER_ID id = 1;
	pwo->id(id++);

	return _addWatcher(szpath, pwo);
}
Example #30
0
void CudaCompiler::splitPathList( std::vector<std::string>& res, 
                                  const std::string& value)
{
  for (size_t startIdx = 0u; startIdx < value.length();)
  {
    size_t endIdx = value.find_first_of(':', startIdx);
    
    if (std::string::npos == endIdx) {
      endIdx = value.length();
    }

    std::string item = value.substr( startIdx, endIdx-startIdx);
    
    if ((item.length() >= 2u) && 
        (item.find_first_of("\"") == 0u) && 
        (item.find_last_of("\"") == (item.length()-1u))) 
    {
      item = item.substr( 1u, item.length() - 2u);
    }
    res.push_back(item);

    startIdx = endIdx + 1u;
  }
}