C#

string splittSet = "";
            string test_pattern = @"(.{1,60})(\s{1,2}|$)";
            RegexOptions regexOptions = RegexOptions.None;
            Regex splitText = new Regex(test_pattern, regexOptions);
            string inputData = @"The wolf is thought to be an ice age survivor, dating wolves around 300,000 years ago. The wolf is accepted to be the ancestor of the domestic dog as the wolf is thought to have selectively bred in order to breed appealing traits typical of puppies and to eliminate the not so appealing traits of adult wolves.";
            foreach (Match match in splitText.Matches(inputData))
            {
                if (match.Success)
                {
                    splittSet += match.Groups[0].Value + "\n\r";
                }
            }

splittSet += match.Groups[0].Value + "\n\r";

string splitPatteren = @"(.{1," + count + @"})(\s{1,2}|$)";
           RegexOptions regexOptions = RegexOptions.IgnoreCase;
           Regex splitText = new Regex(splitPatteren, regexOptions);
           StringBuilder result = new StringBuilder();
           foreach (Match match in splitText.Matches(input))
           {
               if (match.Success)
               {
                   result.Append(match.Groups[0].Value + delm);
               }
           }

anil150875 wrote:

graphdata

anil150875 wrote:

AWS

class GroupEntity { }
class ConfigEntity : GroupEntity { }
class DefinitionEntity : GroupEntity { }

class GroupEntity
{
    public List<ConfigEntity> ConfigEntities { get; }
}

class ConfigEntity
{
    public List<DefinitionEntity> DefinitionEntities { get; }
}

class DefinitionEntity { }

public class Parser<T> where T : GroupEntity
{
    public List<T> Data { get; set; }
    
    public void LoadDataFromFile(string fileName)
    {
        List<GroupEntity> allData = Serialization.DeSerializeObject<List<GroupEntity>>(fileName); 
        Data = allData.OfType<T>().ToList();
    }
}

private void LoadDataFromFile(string fileName)
{
    try
    {
        // Lists
        List<RuleGroupEntity> groups = new List<RuleGroupEntity>();
        List<RuleConfigurationEntity> configs = new List<RuleConfigurationEntity>();
        List<RuleDefinitionEntity> definitions = new List<RuleDefinitionEntity>();

        // Deserialize into the Groups
        groups = Serialization.DeSerializeObject<List<RuleGroupEntity>>(fileName);

        // Go through all the data and load the lists
        foreach (var group in groups)
        {
            configs.AddRange(group.RuleConfigurations);

            foreach (var config in group.RuleConfigurations)
            {
                definitions.Add(config.RuleDefinition);
            }
        }

        // Get the parameter type
        Type parameterType = typeof(T);

        // If T is Configurations, the load the Data T property with the configs list
        if (parameterType == typeof(RuleConfigurationEntity))
        {
            Data = (T)Activator.CreateInstance(typeof(T), configs); // <== Something like this is what I want.
        }
    }
    catch (Exception e)
    {
    }
}

public class Parser<T> where T : EntityBase
{
    public List<T> Data { get; set; }
    
    public void LoadDataFromFile(string fileName)
    {
        List<RuleGroupEntity> groups = Serialization.DeSerializeObject<List<RuleGroupEntity>>(fileName);
        switch (typeof(T))
        {
            case typeof(RuleGroupEntity):
            {
                Data = (List<T>)(object)groups;
                break;
            }
            case typeof(RuleConfigurationEntity):
            {
                List<RuleConfigurationEntity> configs = groups.SelectMany(g => g.RuleConfigurations).ToList();
                Data = (List<T>)(object)configs;
                break;
            }
            case typeof(RuleDefinitionEntity):
            {
                List<RuleDefinitionEntity> definitions = groups.SelectMany(g => g.RuleConfigurations).Select(c => c.RuleDefinition).ToList();
                Data = (List<T>)(object)definitions;
                break;
            }
            default:
            {
                throw new NotSupportedException($"Type '{typeof(T)}' is not supported.");
            }
        }
    }
}

public abstract class Parser<T> where T : EntityBase
{
    public List<T> Data { get; set; }
    
    public void LoadDataFromFile(string fileName)
    {
        List<RuleGroupEntity> groups = Serialization.DeSerializeObject<List<RuleGroupEntity>>(fileName);
        LoadDataFromGroups(groups);
    }
    
    protected abstract void LoadDataFromGroups(List<RuleGroupEntity> groups);
}

public class RuleGroupEntityParser : Parser<RuleGroupEntity>
{
    protected override void LoadDataFromGroups(List<RuleGroupEntity> groups)
    {
        Data = groups;
    }
}

public class RuleConfigurationEntityParser : Parser<RuleConfigurationEntity>
{
    protected override void LoadDataFromGroups(List<RuleGroupEntity> groups)
    {
        Data = groups.SelectMany(g => g.RuleConfigurations).ToList();
    }
}

public class RuleDefinitionEntityParser : Parser<RuleDefinitionEntity>
{
    protected override void LoadDataFromGroups(List<RuleGroupEntity> groups)
    {
        Data = groups.SelectMany(g => g.RuleConfigurations).Select(c => c.RuleDefinition).ToList();
    }
}

public T Get(Guid id)
{
    return Data.Where(x => x.Id == id).FirstOrDefault();
}

public T Get(Expression<Func<T, bool>> predicate)
{
    return Data.Where(predicate).FirstOrDefault();
}

public T Get(Func<T, bool> predicate)
{
    return Data.Where(predicate).FirstOrDefault();
}

public T Get(Expression<Func<T, bool>> predicate)
{
    return Data.AsQueryable().Where(predicate).FirstOrDefault();
}

// Old
//T Get(Expression<Func<T, bool>> predicate);

// new
T Get(Func<T, bool> predicate);

//public T Get(Expression<Func<T, bool>> predicate)
//{
//    var collection = GetCollection();
//    return collection.AsQueryable().Where(predicate).FirstOrDefault();
//}

public T Get(Func<T, bool> predicate)
{
    var collection = GetCollection().AsQueryable();
    return collection.Where(predicate).FirstOrDefault();
}

//public T Get(Expression<Func<T, bool>> predicate)
//{
//    throw new NotImplementedException();
//}

public T Get(Func<T, bool> predicate)
{
    return Data.AsQueryable().Where(predicate).FirstOrDefault();
}