Helper class to split a long word into a single one.

image_pdfimage_print

/*
* Author: Kishore Reddy
* Url: http://commonlibrarynet.codeplex.com/
* Title: CommonLibrary.NET
* Copyright: ? 2009 Kishore Reddy
* License: LGPL License
* LicenseUrl: http://commonlibrarynet.codeplex.com/license
* Description: A C# based .NET 3.5 Open-Source collection of reusable components.
* Usage: Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an “AS IS” BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Text;

namespace GenericCode
{
///

/// Helper class to split a long word into a single one.
/// Alternative to possibly using Regular expression.
///

public class TextSplitter
{
///

/// Determine how many times the word has to be split.
///

/// /// ///
internal static int GetNumberOfTimesToSplit(int wordLength, int maxCharsInWord)
{
// Validate.
if (wordLength <= maxCharsInWord) return 0; // Now calc. int splitCount = wordLength / maxCharsInWord; int leftOver = wordLength % maxCharsInWord; if (leftOver > 0) splitCount++;

return splitCount;
}
///

/// Split the word, N number of times.
///

/// The text to split. /// 40 chars in each word. /// ” “ ///
internal static string SplitWord(string text, int charsPerWord, string spacer)
{
// Validate.
if (string.IsNullOrEmpty(text)) { return text; }

// Determine how many times we have to split.
int splitCount = GetNumberOfTimesToSplit(text.Length, charsPerWord);

// Validate.
if (splitCount == 0) return text;

// Use buffer instead of string concatenation.
StringBuilder buffer = new StringBuilder();
int currentPosition = 0;

// Split N number of times.
for (int count = 1; count <= splitCount; count++) { string word = (count < splitCount) ? text.Substring(currentPosition, charsPerWord) : text.Substring(currentPosition); buffer.Append(word); // Condition to prevent adding spacer at the end. // This is to leave the supplied text the same except for splitting ofcourse. if (count < splitCount) buffer.Append(spacer); // Move to next split start position. currentPosition += charsPerWord; } return buffer.ToString(); } ///

/// Check the single line of text for long word that exceeds the
/// maximum allowed.
/// If found, splits the word.
///

/// /// ///
public static string CheckAndSplitText(string text, int maxCharsInWord)
{
// Validate.
if (string.IsNullOrEmpty(text)) return text;

bool isSpacerNewLine = false;
int currentPosition = 0;
int ndxSpace = GetIndexOfSpacer(text, currentPosition, ref isSpacerNewLine);

// Case 1: Single long word.
if (ndxSpace < 0 && text.Length > maxCharsInWord) return SplitWord(text, maxCharsInWord, ” “);

StringBuilder buffer = new StringBuilder();

// Now go through all the text and check word and split.
while ((currentPosition < text.Length && ndxSpace > 0))
{
//Lenght of word
int wordLength = ndxSpace – (currentPosition);
string currentWord = text.Substring(currentPosition, wordLength);
string spacer = isSpacerNewLine ? Environment.NewLine : ” “;

if (wordLength > maxCharsInWord)
{
string splitWord = SplitWord(currentWord, maxCharsInWord, ” “);
buffer.Append(splitWord + spacer);
}
else
{
buffer.Append(currentWord + spacer);
}

currentPosition = (isSpacerNewLine) ? ndxSpace + 2 : ndxSpace + 1;
ndxSpace = GetIndexOfSpacer(text, (currentPosition), ref isSpacerNewLine);
}

// Final check.. no space found but check complete length now.
if (currentPosition < text.Length && ndxSpace < 0) { //Lenght of word int wordLength = (text.Length) - currentPosition; string currentWord = text.Substring(currentPosition, wordLength); string spacer = isSpacerNewLine ? Environment.NewLine : " "; if (wordLength > maxCharsInWord)
{
string splitWord = SplitWord(currentWord, maxCharsInWord, ” “);
buffer.Append(splitWord);
}
else
{
buffer.Append(currentWord);
}
}
return buffer.ToString();
}
///

/// Get the index of a spacer ( space” ” or newline )
///

/// /// ///
public static int GetIndexOfSpacer(string txt, int currentPosition, ref bool isNewLine)
{
// Take the first spacer that you find. it could be eithr
// space or newline, if space is before the newline take space
// otherwise newline.
int ndxSpace = txt.IndexOf(” “, currentPosition);
int ndxNewLine = txt.IndexOf(Environment.NewLine, currentPosition);
bool hasSpace = ndxSpace > -1;
bool hasNewLine = ndxNewLine > -1;
isNewLine = false;

// Found both space and newline.
if (hasSpace && hasNewLine)
{
if (ndxSpace < ndxNewLine) { return ndxSpace; } isNewLine = true; return ndxNewLine; } // Found space only. if (hasSpace && !hasNewLine) { return ndxSpace; } // Found newline only. if (!hasSpace && hasNewLine) { isNewLine = true; return ndxNewLine; } // no space or newline. return -1; } } } [/csharp]

This entry was posted in Data Types. Bookmark the permalink.