示例#1
0
//============================================================================
//		NDataEncoder::B64_Encode : Encode to Base64.
//----------------------------------------------------------------------------
NString NDataEncoder::B64_Encode(const NData &theValue)
{	NData					theBuffer;
	NString					theString;
	base64_encodestate		theState;
	char					*dataPtr;
	NIndex					dataSize;



	// Get the state we need
	base64_init_encodestate(&theState);

	if (theValue.IsEmpty() || !theBuffer.SetSize(theValue.GetSize() * 2))
		return(theString);



	// Encode the value
	dataPtr   = (char *) theBuffer.GetData();
	dataSize  = base64_encode_block((const char *) theValue.GetData(), theValue.GetSize(), dataPtr, &theState);
	theString = NString(dataPtr, dataSize);

	dataSize = base64_encode_blockend(dataPtr, &theState);
	if (dataSize != 0)
		theString += NString(dataPtr, dataSize);



	// Remove the trailing newline
	NN_ASSERT(theString.GetRight(1) == "\n");
	theString.TrimRight(1);

	return(theString);
}
示例#2
0
NString Socket::recv()
{
	if (_status == SocketStatus::CONNECTED)
        {
		return NString();
        }

	memset(_buf, 0, 8192);
	int result = ::recv(_socket, _buf, 8192, 0);

	if (result == 0)
	{
		setError(SocketError::RECV_ERROR);
	}
	else if (result == -1)
	{
		setError(SocketError::BROKEN_PIPE);
	}

	if (result > 0)
	{
		return NString(_buf, result);
	}
	else
	{
		return NString();
	}
}
示例#3
0
//============================================================================
//		NDataEncoder::Hex_Encode : Encode to hex.
//----------------------------------------------------------------------------
NString NDataEncoder::Hex_Encode(const NData &theValue)
{	NIndex			n, theSize;
	NData			tmpBuffer;
	NString			theResult;
	const uint8_t	*dataPtr;
	char			*textPtr;



	// Get the state we need
	theSize = theValue.GetSize();
	dataPtr = theValue.GetData();
	textPtr = (char *) tmpBuffer.AppendData((theSize * 2) + 1);

	if (theSize == 0 || dataPtr == NULL || textPtr == NULL)
		return(theResult);



	// Convert to a string
	for (n = 0; n < theSize; n++)
		{
		sprintf(textPtr, "%.2X", dataPtr[n]);
		textPtr += 2;
		}
	
	theResult = NString(tmpBuffer);
	
	return(theResult);
}
示例#4
0
文件: NURL.cpp 项目: refnum/nano
//============================================================================
//		NURL::NURL : Constructor.
//----------------------------------------------------------------------------
NURL::NURL(const char *theURL)
{


	// Initialize ourselves
	mValue = NString(theURL);
}
示例#5
0
//============================================================================
//		NFileUtilities::GetFileText : Get a file as text.
//----------------------------------------------------------------------------
NString NFileUtilities::GetFileText(const NFile &theFile, NStringEncoding theEncoding)
{	NStringEncoder		theEncoder;
	NData				theData;
	NString				theText;



	// Get the state we need
	theData = GetFileData(theFile);
	if (theData.IsEmpty())
		return(theText);
	
	
	
	// Get the text
	if (theEncoding == kNStringEncodingInvalid)
		{
		theEncoding = theEncoder.GetEncoding(theData);
		NN_ASSERT(theEncoding != kNStringEncodingInvalid);
		}

	if (theEncoding != kNStringEncodingInvalid)
		theText = NString(theData, theEncoding);
		
	return(theText);
}
                NServiceClientFactoryConfig * NServiceClientFactoryConfigFile::parseConfigEntry(pugi::xml_node & node)
                {
                    NServiceClientFactoryConfig * config = NULL;
                    try
                    {
                        config = new NServiceClientFactoryConfig();

                        for (pugi::xml_node setting : node.children())
                        {
                            if (setting.type() == pugi::node_element)
                            {
                                if (NString("name").compare(setting.name()) == 0)
                                {
                                    config->setName(setting.child_value());
                                }
                                else if (NString("factory").compare(setting.name()) == 0)
                                {
                                    config->setFactory(setting.child_value());
                                }
                                else if (NString("component").compare(setting.name()) == 0)
                                {
                                    config->setComponent(setting.child_value());
                                }
                                else if (NString("library").compare(setting.name()) == 0)
                                {
                                    config->setLibrary(setting.child_value());
                                }
                            }
                        }

                        if (config->getName().empty()
                            || config->getFactory().empty()
                            || config->getComponent().empty()
                            || config->getLibrary().empty())
                        {
                            throw NRuntimeException("Service client factory configuratin is incomplete");
                        }
                    }
                    catch (...)
                    {
                        if (config != NULL)
                            delete config;
                        return NULL;
                    }
                    return config;
                }
            NConnectionConfig * NConnectionConfigFile::parseConfigEntry(pugi::xml_node & node)
            {
                NConnectionConfig * config = NULL;
                try
                {
                    config = new NConnectionConfig();

                    for (pugi::xml_node setting : node.children())
                    {
                        if (setting.type() == pugi::node_element)
                        {
                            if (NString("name").compare(setting.name()) == 0)
                            {
                                config->setName(setting.child_value());
                            }
                            else if (NString("host").compare(setting.name()) == 0)
                            {
                                config->setHost(setting.child_value());
                            }
                            else if (NString("port").compare(setting.name()) == 0)
                            {
                                config->setPort(NUnsignedShort::fromString(setting.child_value()));
                            }
                            else if (NString("user").compare(setting.name()) == 0)
                            {
                                config->setUser(setting.child_value());
                            }
                            else if (NString("password").compare(setting.name()) == 0)
                            {
                                config->setPassword(setting.child_value());
                            }
                            else if (NString("schema").compare(setting.name()) == 0)
                            {
                                config->setSchema(setting.child_value());
                            }
                            else if (NString("type").compare(setting.name()) == 0)
                            {
                                config->setConnectionType(NConnectionType::getByValue(setting.child_value()));
                            }
                        }
                    }
                    if (config->getName().empty()
                            || config->getHost().empty()
                            || config->getUser().empty()
                            || config->getPassword().empty()
                            || config->getSchema().empty()
                            || config->getPort() == NUnsignedShort(0)
                            || config->getConnectionType() == NConnectionType::UNKNOWN)
                    {
                        throw NRuntimeException("Connection configuration is incomplete");
                    }
                }
                catch (...)
                {
                    if (config != NULL)
                        delete config;
                    return NULL;
                }
                return config;
            }
示例#8
0
std::string NString::trim()
{
  int i = 0;
  while (i < (int)size() && at(i) > 0 && isspace(at(i))) i++;
  NString str = NString(substr(i));
  if (str != "") {
    i = size() - 1;
    while (i > 0 && at(i) > 0 && isspace(at(i))) i--;
    if (++i < (int)this->size())
      str.at(i) = '\0';
  }

  return str;
}
示例#9
0
//============================================================================
//      NFileUtilities::GetCWD : Get the current working directory.
//----------------------------------------------------------------------------
NFile NFileUtilities::GetCWD(void)
{	char		*thePath;
	NFile		theFile;



	// Get the directory
	thePath = NTargetPOSIX::getcwd(NULL, 0);
	if (thePath != NULL)
		{
		theFile = NFile(NString(thePath, kNStringLength));
		free(thePath);
		}

	return(theFile);
}
示例#10
0
//============================================================================
//		NDBResult::GetValueString : Get a string value.
//----------------------------------------------------------------------------
NString NDBResult::GetValueString(NIndex theIndex) const
{	NString			theResult;
	const void		*thePtr;
	NIndex			theSize;



	// Validate our parameters
	NN_ASSERT(theIndex < GetSize());



	// Get the value
	thePtr  = (const void *) sqlite3_column_text( (sqlite3_stmt *) mResult, theIndex);
	theSize = (NIndex      ) sqlite3_column_bytes((sqlite3_stmt *) mResult, theIndex);

	if (thePtr != NULL && theSize != 0)
		theResult = NString(thePtr, theSize, kNStringEncodingUTF8);

	return(theResult);
}
            INList<NConnectionConfig *> * NConnectionConfigFile::parseXmlDocument(pugi::xml_document * document)
            {
                INList<NConnectionConfig *> * result = new NList<NConnectionConfig *>();

                pugi::xml_node connections = document->child("databases");
                if (connections.type() != pugi::node_null)
                {
                    for (pugi::xml_node connection : connections.children())
                    {
                        if (connection.type() == pugi::node_element)
                        {
                            if (NString("database").compare(connection.name()) == 0)
                            {
                                NConnectionConfig * config = parseConfigEntry(connection);
                                if (config != NULL)
                                    result->add(config);
                            }
                        }
                    }
                }

                return result;
            }
                INList<NServiceClientFactoryConfig *> * NServiceClientFactoryConfigFile::parseXmlDocument(pugi::xml_document * document)
                {
                    INList<NServiceClientFactoryConfig *> * result = new NList<NServiceClientFactoryConfig *>();

                    pugi::xml_node factories = document->child("factories");
                    if (factories.type() != pugi::node_null)
                    {
                        for (pugi::xml_node factory : factories.children())
                        {
                            if (factory.type() == pugi::node_element)
                            {
                                if (NString("factory").compare(factory.name()) == 0)
                                {
                                    NServiceClientFactoryConfig * config = parseConfigEntry(factory);
                                    if (config != NULL)
                                        result->add(config);
                                }
                            }
                        }
                    }

                    return result;
                }
	static NString GetLongProductName(const NLicenseProductInfo & productInfo)
	{
		HNString handle;
		NCheck(NLicManGetLongProductNameForProductInfoN(productInfo.GetHandle(), &handle));
		return NString(handle, true);
	}
	static NString GetShortProductName(NUInt productId, NLicenseType type)
	{
		HNString handle;
		NCheck(NLicManGetShortProductNameN(productId, type, &handle));
		return NString(handle, true);
	}
示例#15
0
文件: TEncoder.cpp 项目: x414e54/nano
//		Test case
//----------------------------------------------------------------------------
TEST_NENCODER("Encoding")
{	NData			dataXML, dataBinary;
	UInt32			adlerData;
	NDataDigest		theDigest;
	NVariant		theValue;
	NString			textXML;



	// Perform the test
	dataXML    = theEncoder.Encode(theObject, kNEncoderXML);
	dataBinary = theEncoder.Encode(theObject, kNEncoderBinary);

	textXML   = NString(dataXML);
	adlerData = theDigest.GetAdler32(dataBinary);

	REQUIRE(textXML   == kResultXML);
	REQUIRE(adlerData == kResultBinary);
}





//============================================================================
//		Test case
//----------------------------------------------------------------------------
TEST_NENCODER("Decoding")
{	NData		dataXML, dataBinary;
	NString GetVendorValue() const
	{
		return NString(hVendorValue, false);
	}
示例#17
0
namespace nkit {

NString NString::Empty = NString("");


NString::NString()
  : std::string()
{
}

NString::NString(const std::string& value)
  : std::string(value)
{
}

NString::NString(cstr value)
  : std::string(value)
{
}

int NString::indexOf(char ch) {
  size_t s = find(ch);
  return (s >= size()) ? -1 : s;
}
static NString Empty;

std::string NString::trim_start()
{
  int i = 0;
  while (i < (int)size() && isspace(at(i))) i++;
  return substr(i);
}

std::string NString::trim()
{
  int i = 0;
  while (i < (int)size() && at(i) > 0 && isspace(at(i))) i++;
  NString str = NString(substr(i));
  if (str != "") {
    i = size() - 1;
    while (i > 0 && at(i) > 0 && isspace(at(i))) i--;
    if (++i < (int)this->size())
      str.at(i) = '\0';
  }

  return str;
}

bool NString::ends_with(cstr string)
{
  int lg = strlen(string);
  return memcmp(&(c_str()[size() - lg]), string, lg) == 0;
}


std::string NString::extract_until(char ch, int from, char escape)
{
  std::string pfx;
  int k = -1;
  while (k < 0) {
    k = find(ch, from);
    if (k < 0)
      return "";
    if (at(k-1) == escape) {
      from = k+1;
      k = -1;
    }
  }

  pfx = substr(0, k+1);
  assign(&c_str()[k+1]);
  return pfx;
}

void NString::split(cstr delim, NStrings* strings)
{
  char* ctx;
  char* buf = strdup(this->c_str());

  char* ptr = strtok_r(buf, delim, &ctx);
  while (ptr) {
    strings->push_back(new NString(ptr));
    ptr = strtok_r(NULL, delim, &ctx);
  }

  free(buf);
}


NString NString::Concat(cstr str, ...)
{
  va_list ap;
  NString string(str);

  va_start(ap, str);
  for (;;) {
    cstr nx = va_arg(ap, cstr);
    if (nx)
      string += nx;
    else
      break;
  }

  va_end(ap);
  return string;
}

NString::operator cstr()
{
  return this->c_str();
}

NString::operator std::string()
{
  return std::string(this->c_str());
}

}  // namespace nkit
示例#18
0
NString NString::clone()
{
	return NString(_buffer->c_str(), _buffer->size());
}
 NString GetVersion() const
 {
     return NString(hVersion, false);
 }
示例#20
0
	static bool TryParse(const NType & type, const NStringWrapper & value, NInt32 * pValue) { return TryParse(type, value, NString(), pValue); }
示例#21
0
int main(void) {
	NDataStream data;
	NDataStream num;
	nint16 val = 666; // 0x29a


	// Operators: you can use then to set or append to a NDataStream
	data = "teste";
	data += 0; // This one goes as a nint32, thus will use 4 bytes.
	data += "abc";
	data += val;
	data += "-end-";
	
	// The size() method displays the current size of the data 
	NMessage::print() << "Size: " << data.size();

	// You can use subscript operators to access data. 
	for (nuint32 i = 0; i < data.size(); i++) {
		NMessage::print() << NString().arg("%02x = %c", data[i], data[i]);
	}

	// Operators: they accept several data types, including short ints
	num = val;
	val = 0;
	NMessage::print() << NString().arg("%02x = %i", val, val);
	

	// And you can convert it back to its original type
	val = num.toInt16();
	NMessage::print() << NString().arg("%02x = %i\n", val, val);
	
	
	// You can convert it to a string, too
	NMessage::print() << "1) Data: " << data.toString();
	
	try {
		// You can also define the range ...
		NMessage::print() << "2) Data: " << data.toString(2, 10);
		
		// However, if you exceed the bounds of the stream it will
		// throw a NException exception. Be careful.
		NMessage::print() << "3) Data: " << data.toString(89, 1023);
	}
	catch (NException &e) {
		NWarning::print() << "Out of bounds: " << e.getDescription();
	}
		
	val = 0;

	// You may set the byte ordering:
	num.setByteOrder(NDataStream::N_LITTLE_ENDIAN);
	num = 666; // 0x29a
	
	// Again, be careful: it affects the order in which bytes are stored
	for (nuint32 i = 0; i < num.size(); i++) {
		NMessage::print() << NString().arg("%02x = %i", num[i], num[i]);
	}
	
	// ... but not how they are converted
	val = num.toInt16();
	NMessage::print() << NString().arg("%02x = %i", val, val);

	return 0;
}
示例#22
0
 operator NString()
 {
   NString str = NString::Empty;
   str += NString(namespace_) + NString(name_);
   return str;
 }
示例#23
0
	NString ReadToEnd()
	{
		HNString hValue;
		NCheck(NTextReaderReadToEnd(GetHandle(), &hValue));
		return NString(hValue, true);
	}
示例#24
0
文件: loot.cpp 项目: ChunHungLiu/Bot
void LootModule::loot(uint32_t id)
{
	auto packet = NString("get 1 ") << _player->getIngameID() << ' ' << id;
	Sender::get()->send(_session, packet);
}
示例#25
0
	static NString ToString(const NType & type, NInt32 value, const NStringWrapper & format = NString())
	{
		HNString hValue;
		NCheck(NEnumToStringN(type.GetHandle(), value, format.GetHandle(), &hValue));
		return NString(hValue, true);
	}
    NIndexOutOfBoundsException::NIndexOutOfBoundsException() : NRuntimeException(NString("Index is out of bounds"))
    {

    }
示例#27
0
	static NInt32 Parse(const NType & type, const NStringWrapper & value, const NStringWrapper & format = NString())
	{
		NInt32 result;
		NCheck(NEnumParseN(type.GetHandle(), value.GetHandle(), format.GetHandle(), &result));
		return result;
	}
 NString GetName() const
 {
     return NString(hName, false);
 }